func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError404ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError404ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/201/C/404/D/default/Error/response/404/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
get200ModelA201ModelC404ModelDDefaultError404ValidCreateRequest creates the Get200ModelA201ModelC404ModelDDefaultError404Valid request.
package httpinfrastructuregroup
import (
	"context"
	"errors"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
)
type MultipleResponsesClient struct {
	con *Connection
}
func NewMultipleResponsesClient(con *Connection) *MultipleResponsesClient {
	return &MultipleResponsesClient{con: con}
}
func (client *MultipleResponsesClient) Get200Model201ModelDefaultError200Valid(ctx context.Context, options *MultipleResponsesGet200Model201ModelDefaultError200ValidOptions) (MultipleResponsesGet200Model201ModelDefaultError200ValidResponse, error) {
	req, err := client.get200Model201ModelDefaultError200ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model201ModelDefaultError200ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model201ModelDefaultError200ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated) {
		return MultipleResponsesGet200Model201ModelDefaultError200ValidResponse{}, client.get200Model201ModelDefaultError200ValidHandleError(resp)
	}
	return client.get200Model201ModelDefaultError200ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError200ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model201ModelDefaultError200ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/201/B/default/Error/response/200/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError200ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200Model201ModelDefaultError200ValidResponse, error) {
	result := MultipleResponsesGet200Model201ModelDefaultError200ValidResponse{RawResponse: resp}
	switch resp.StatusCode {
	case http.StatusOK:
		var val MyException
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200Model201ModelDefaultError200ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusCreated:
		var val B
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200Model201ModelDefaultError200ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	default:
		return MultipleResponsesGet200Model201ModelDefaultError200ValidResponse{}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError200ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200Model201ModelDefaultError201Valid(ctx context.Context, options *MultipleResponsesGet200Model201ModelDefaultError201ValidOptions) (MultipleResponsesGet200Model201ModelDefaultError201ValidResponse, error) {
	req, err := client.get200Model201ModelDefaultError201ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model201ModelDefaultError201ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model201ModelDefaultError201ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated) {
		return MultipleResponsesGet200Model201ModelDefaultError201ValidResponse{}, client.get200Model201ModelDefaultError201ValidHandleError(resp)
	}
	return client.get200Model201ModelDefaultError201ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError201ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model201ModelDefaultError201ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/201/B/default/Error/response/201/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError201ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200Model201ModelDefaultError201ValidResponse, error) {
	result := MultipleResponsesGet200Model201ModelDefaultError201ValidResponse{RawResponse: resp}
	switch resp.StatusCode {
	case http.StatusOK:
		var val MyException
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200Model201ModelDefaultError201ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusCreated:
		var val B
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200Model201ModelDefaultError201ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	default:
		return MultipleResponsesGet200Model201ModelDefaultError201ValidResponse{}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError201ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200Model201ModelDefaultError400Valid(ctx context.Context, options *MultipleResponsesGet200Model201ModelDefaultError400ValidOptions) (MultipleResponsesGet200Model201ModelDefaultError400ValidResponse, error) {
	req, err := client.get200Model201ModelDefaultError400ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model201ModelDefaultError400ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model201ModelDefaultError400ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated) {
		return MultipleResponsesGet200Model201ModelDefaultError400ValidResponse{}, client.get200Model201ModelDefaultError400ValidHandleError(resp)
	}
	return client.get200Model201ModelDefaultError400ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError400ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model201ModelDefaultError400ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/201/B/default/Error/response/400/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError400ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200Model201ModelDefaultError400ValidResponse, error) {
	result := MultipleResponsesGet200Model201ModelDefaultError400ValidResponse{RawResponse: resp}
	switch resp.StatusCode {
	case http.StatusOK:
		var val MyException
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200Model201ModelDefaultError400ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusCreated:
		var val B
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200Model201ModelDefaultError400ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	default:
		return MultipleResponsesGet200Model201ModelDefaultError400ValidResponse{}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model201ModelDefaultError400ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200Model204NoModelDefaultError200Valid(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError200ValidOptions) (MultipleResponsesGet200Model204NoModelDefaultError200ValidResponse, error) {
	req, err := client.get200Model204NoModelDefaultError200ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError200ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError200ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusNoContent) {
		return MultipleResponsesGet200Model204NoModelDefaultError200ValidResponse{}, client.get200Model204NoModelDefaultError200ValidHandleError(resp)
	}
	return client.get200Model204NoModelDefaultError200ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError200ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError200ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/204/none/default/Error/response/200/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError200ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200Model204NoModelDefaultError200ValidResponse, error) {
	result := MultipleResponsesGet200Model204NoModelDefaultError200ValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError200ValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError200ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200Model204NoModelDefaultError201Invalid(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError201InvalidOptions) (MultipleResponsesGet200Model204NoModelDefaultError201InvalidResponse, error) {
	req, err := client.get200Model204NoModelDefaultError201InvalidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError201InvalidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError201InvalidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusNoContent) {
		return MultipleResponsesGet200Model204NoModelDefaultError201InvalidResponse{}, client.get200Model204NoModelDefaultError201InvalidHandleError(resp)
	}
	return client.get200Model204NoModelDefaultError201InvalidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError201InvalidCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError201InvalidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/204/none/default/Error/response/201/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError201InvalidHandleResponse(resp *http.Response) (MultipleResponsesGet200Model204NoModelDefaultError201InvalidResponse, error) {
	result := MultipleResponsesGet200Model204NoModelDefaultError201InvalidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError201InvalidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError201InvalidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200Model204NoModelDefaultError202None(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError202NoneOptions) (MultipleResponsesGet200Model204NoModelDefaultError202NoneResponse, error) {
	req, err := client.get200Model204NoModelDefaultError202NoneCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError202NoneResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError202NoneResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusNoContent) {
		return MultipleResponsesGet200Model204NoModelDefaultError202NoneResponse{}, client.get200Model204NoModelDefaultError202NoneHandleError(resp)
	}
	return client.get200Model204NoModelDefaultError202NoneHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError202NoneCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError202NoneOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/204/none/default/Error/response/202/none"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError202NoneHandleResponse(resp *http.Response) (MultipleResponsesGet200Model204NoModelDefaultError202NoneResponse, error) {
	result := MultipleResponsesGet200Model204NoModelDefaultError202NoneResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError202NoneResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError202NoneHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200Model204NoModelDefaultError204Valid(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError204ValidOptions) (MultipleResponsesGet200Model204NoModelDefaultError204ValidResponse, error) {
	req, err := client.get200Model204NoModelDefaultError204ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError204ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError204ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusNoContent) {
		return MultipleResponsesGet200Model204NoModelDefaultError204ValidResponse{}, client.get200Model204NoModelDefaultError204ValidHandleError(resp)
	}
	return client.get200Model204NoModelDefaultError204ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError204ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError204ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/204/none/default/Error/response/204/none"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError204ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200Model204NoModelDefaultError204ValidResponse, error) {
	result := MultipleResponsesGet200Model204NoModelDefaultError204ValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError204ValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError204ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200Model204NoModelDefaultError400Valid(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError400ValidOptions) (MultipleResponsesGet200Model204NoModelDefaultError400ValidResponse, error) {
	req, err := client.get200Model204NoModelDefaultError400ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError400ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError400ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusNoContent) {
		return MultipleResponsesGet200Model204NoModelDefaultError400ValidResponse{}, client.get200Model204NoModelDefaultError400ValidHandleError(resp)
	}
	return client.get200Model204NoModelDefaultError400ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError400ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200Model204NoModelDefaultError400ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/204/none/default/Error/response/400/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError400ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200Model204NoModelDefaultError400ValidResponse, error) {
	result := MultipleResponsesGet200Model204NoModelDefaultError400ValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200Model204NoModelDefaultError400ValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200Model204NoModelDefaultError400ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200ModelA200Invalid(ctx context.Context, options *MultipleResponsesGet200ModelA200InvalidOptions) (MultipleResponsesGet200ModelA200InvalidResponse, error) {
	req, err := client.get200ModelA200InvalidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200ModelA200InvalidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200ModelA200InvalidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return MultipleResponsesGet200ModelA200InvalidResponse{}, client.get200ModelA200InvalidHandleError(resp)
	}
	return client.get200ModelA200InvalidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200ModelA200InvalidCreateRequest(ctx context.Context, options *MultipleResponsesGet200ModelA200InvalidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/response/200/invalid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200ModelA200InvalidHandleResponse(resp *http.Response) (MultipleResponsesGet200ModelA200InvalidResponse, error) {
	result := MultipleResponsesGet200ModelA200InvalidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200ModelA200InvalidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200ModelA200InvalidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *MultipleResponsesClient) Get200ModelA200None(ctx context.Context, options *MultipleResponsesGet200ModelA200NoneOptions) (MultipleResponsesGet200ModelA200NoneResponse, error) {
	req, err := client.get200ModelA200NoneCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200ModelA200NoneResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200ModelA200NoneResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return MultipleResponsesGet200ModelA200NoneResponse{}, client.get200ModelA200NoneHandleError(resp)
	}
	return client.get200ModelA200NoneHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200ModelA200NoneCreateRequest(ctx context.Context, options *MultipleResponsesGet200ModelA200NoneOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/response/200/none"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200ModelA200NoneHandleResponse(resp *http.Response) (MultipleResponsesGet200ModelA200NoneResponse, error) {
	result := MultipleResponsesGet200ModelA200NoneResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200ModelA200NoneResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200ModelA200NoneHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *MultipleResponsesClient) Get200ModelA200Valid(ctx context.Context, options *MultipleResponsesGet200ModelA200ValidOptions) (MultipleResponsesGet200ModelA200ValidResponse, error) {
	req, err := client.get200ModelA200ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200ModelA200ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200ModelA200ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return MultipleResponsesGet200ModelA200ValidResponse{}, client.get200ModelA200ValidHandleError(resp)
	}
	return client.get200ModelA200ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200ModelA200ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200ModelA200ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/response/200/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200ModelA200ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200ModelA200ValidResponse, error) {
	result := MultipleResponsesGet200ModelA200ValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.MyException); err != nil {
		return MultipleResponsesGet200ModelA200ValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200ModelA200ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError200Valid(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidOptions) (MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse, error) {
	req, err := client.get200ModelA201ModelC404ModelDDefaultError200ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusNotFound) {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{}, client.get200ModelA201ModelC404ModelDDefaultError200ValidHandleError(resp)
	}
	return client.get200ModelA201ModelC404ModelDDefaultError200ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError200ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/201/C/404/D/default/Error/response/200/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError200ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse, error) {
	result := MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{RawResponse: resp}
	switch resp.StatusCode {
	case http.StatusOK:
		var val MyException
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusCreated:
		var val C
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusNotFound:
		var val D
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	default:
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError200ValidResponse{}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError200ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError201Valid(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidOptions) (MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse, error) {
	req, err := client.get200ModelA201ModelC404ModelDDefaultError201ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusNotFound) {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{}, client.get200ModelA201ModelC404ModelDDefaultError201ValidHandleError(resp)
	}
	return client.get200ModelA201ModelC404ModelDDefaultError201ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError201ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/201/C/404/D/default/Error/response/201/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError201ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse, error) {
	result := MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{RawResponse: resp}
	switch resp.StatusCode {
	case http.StatusOK:
		var val MyException
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusCreated:
		var val C
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusNotFound:
		var val D
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	default:
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError201ValidResponse{}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError201ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError400Valid(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidOptions) (MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse, error) {
	req, err := client.get200ModelA201ModelC404ModelDDefaultError400ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusNotFound) {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{}, client.get200ModelA201ModelC404ModelDDefaultError400ValidHandleError(resp)
	}
	return client.get200ModelA201ModelC404ModelDDefaultError400ValidHandleResponse(resp)
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError400ValidCreateRequest(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidOptions) (*policy.Request, error) {
	urlPath := "/http/payloads/200/A/201/C/404/D/default/Error/response/400/valid"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError400ValidHandleResponse(resp *http.Response) (MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse, error) {
	result := MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{RawResponse: resp}
	switch resp.StatusCode {
	case http.StatusOK:
		var val MyException
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusCreated:
		var val C
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	case http.StatusNotFound:
		var val D
		if err := runtime.UnmarshalAsJSON(resp, &val); err != nil {
			return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{}, runtime.NewResponseError(err, resp)
		}
		result.Value = val
	default:
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError400ValidResponse{}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)
	}
	return result, nil
}
func (client *MultipleResponsesClient) get200ModelA201ModelC404ModelDDefaultError400ValidHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *MultipleResponsesClient) Get200ModelA201ModelC404ModelDDefaultError404Valid(ctx context.Context, options *MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError404ValidOptions) (MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError404ValidResponse, error) {
	req, err := client.get200ModelA201ModelC404ModelDDefaultError404ValidCreateRequest(ctx, options)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError404ValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError404ValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusNotFound) {
		return MultipleResponsesGet200ModelA201ModelC404ModelDDefaultError404ValidResponse{}, client.get200ModelA201ModelC404ModelDDefaultError404ValidHandleError(resp)
	}
	return client.get200ModelA201ModelC404ModelDDefaultError404ValidHandleResponse(resp)
}