func (client *PolymorphismClient) putComplicatedCreateRequest(ctx context.Context, complexBody SalmonClassification, options *PolymorphismPutComplicatedOptions) (*policy.Request, error) {
	urlPath := "/complex/polymorphism/complicated"
	req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, runtime.MarshalAsJSON(req, complexBody)
}
putComplicatedCreateRequest creates the PutComplicated request.
package complexgroup
import (
	"context"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
)
type PolymorphismClient struct {
	con *Connection
}
func NewPolymorphismClient(con *Connection) *PolymorphismClient {
	return &PolymorphismClient{con: con}
}
func (client *PolymorphismClient) GetComplicated(ctx context.Context, options *PolymorphismGetComplicatedOptions) (PolymorphismGetComplicatedResponse, error) {
	req, err := client.getComplicatedCreateRequest(ctx, options)
	if err != nil {
		return PolymorphismGetComplicatedResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PolymorphismGetComplicatedResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PolymorphismGetComplicatedResponse{}, client.getComplicatedHandleError(resp)
	}
	return client.getComplicatedHandleResponse(resp)
}
func (client *PolymorphismClient) getComplicatedCreateRequest(ctx context.Context, options *PolymorphismGetComplicatedOptions) (*policy.Request, error) {
	urlPath := "/complex/polymorphism/complicated"
	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 *PolymorphismClient) getComplicatedHandleResponse(resp *http.Response) (PolymorphismGetComplicatedResponse, error) {
	result := PolymorphismGetComplicatedResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result); err != nil {
		return PolymorphismGetComplicatedResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PolymorphismClient) getComplicatedHandleError(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 *PolymorphismClient) GetComposedWithDiscriminator(ctx context.Context, options *PolymorphismGetComposedWithDiscriminatorOptions) (PolymorphismGetComposedWithDiscriminatorResponse, error) {
	req, err := client.getComposedWithDiscriminatorCreateRequest(ctx, options)
	if err != nil {
		return PolymorphismGetComposedWithDiscriminatorResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PolymorphismGetComposedWithDiscriminatorResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PolymorphismGetComposedWithDiscriminatorResponse{}, client.getComposedWithDiscriminatorHandleError(resp)
	}
	return client.getComposedWithDiscriminatorHandleResponse(resp)
}
func (client *PolymorphismClient) getComposedWithDiscriminatorCreateRequest(ctx context.Context, options *PolymorphismGetComposedWithDiscriminatorOptions) (*policy.Request, error) {
	urlPath := "/complex/polymorphism/composedWithDiscriminator"
	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 *PolymorphismClient) getComposedWithDiscriminatorHandleResponse(resp *http.Response) (PolymorphismGetComposedWithDiscriminatorResponse, error) {
	result := PolymorphismGetComposedWithDiscriminatorResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.DotFishMarket); err != nil {
		return PolymorphismGetComposedWithDiscriminatorResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PolymorphismClient) getComposedWithDiscriminatorHandleError(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 *PolymorphismClient) GetComposedWithoutDiscriminator(ctx context.Context, options *PolymorphismGetComposedWithoutDiscriminatorOptions) (PolymorphismGetComposedWithoutDiscriminatorResponse, error) {
	req, err := client.getComposedWithoutDiscriminatorCreateRequest(ctx, options)
	if err != nil {
		return PolymorphismGetComposedWithoutDiscriminatorResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PolymorphismGetComposedWithoutDiscriminatorResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PolymorphismGetComposedWithoutDiscriminatorResponse{}, client.getComposedWithoutDiscriminatorHandleError(resp)
	}
	return client.getComposedWithoutDiscriminatorHandleResponse(resp)
}
func (client *PolymorphismClient) getComposedWithoutDiscriminatorCreateRequest(ctx context.Context, options *PolymorphismGetComposedWithoutDiscriminatorOptions) (*policy.Request, error) {
	urlPath := "/complex/polymorphism/composedWithoutDiscriminator"
	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 *PolymorphismClient) getComposedWithoutDiscriminatorHandleResponse(resp *http.Response) (PolymorphismGetComposedWithoutDiscriminatorResponse, error) {
	result := PolymorphismGetComposedWithoutDiscriminatorResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.DotFishMarket); err != nil {
		return PolymorphismGetComposedWithoutDiscriminatorResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PolymorphismClient) getComposedWithoutDiscriminatorHandleError(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 *PolymorphismClient) GetDotSyntax(ctx context.Context, options *PolymorphismGetDotSyntaxOptions) (PolymorphismGetDotSyntaxResponse, error) {
	req, err := client.getDotSyntaxCreateRequest(ctx, options)
	if err != nil {
		return PolymorphismGetDotSyntaxResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PolymorphismGetDotSyntaxResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PolymorphismGetDotSyntaxResponse{}, client.getDotSyntaxHandleError(resp)
	}
	return client.getDotSyntaxHandleResponse(resp)
}
func (client *PolymorphismClient) getDotSyntaxCreateRequest(ctx context.Context, options *PolymorphismGetDotSyntaxOptions) (*policy.Request, error) {
	urlPath := "/complex/polymorphism/dotsyntax"
	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 *PolymorphismClient) getDotSyntaxHandleResponse(resp *http.Response) (PolymorphismGetDotSyntaxResponse, error) {
	result := PolymorphismGetDotSyntaxResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result); err != nil {
		return PolymorphismGetDotSyntaxResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PolymorphismClient) getDotSyntaxHandleError(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 *PolymorphismClient) GetValid(ctx context.Context, options *PolymorphismGetValidOptions) (PolymorphismGetValidResponse, error) {
	req, err := client.getValidCreateRequest(ctx, options)
	if err != nil {
		return PolymorphismGetValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PolymorphismGetValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PolymorphismGetValidResponse{}, client.getValidHandleError(resp)
	}
	return client.getValidHandleResponse(resp)
}
func (client *PolymorphismClient) getValidCreateRequest(ctx context.Context, options *PolymorphismGetValidOptions) (*policy.Request, error) {
	urlPath := "/complex/polymorphism/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 *PolymorphismClient) getValidHandleResponse(resp *http.Response) (PolymorphismGetValidResponse, error) {
	result := PolymorphismGetValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result); err != nil {
		return PolymorphismGetValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PolymorphismClient) getValidHandleError(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 *PolymorphismClient) PutComplicated(ctx context.Context, complexBody SalmonClassification, options *PolymorphismPutComplicatedOptions) (PolymorphismPutComplicatedResponse, error) {
	req, err := client.putComplicatedCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PolymorphismPutComplicatedResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PolymorphismPutComplicatedResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PolymorphismPutComplicatedResponse{}, client.putComplicatedHandleError(resp)
	}
	return PolymorphismPutComplicatedResponse{RawResponse: resp}, nil
}