func (client *PrimitiveClient) PutLong(ctx context.Context, complexBody LongWrapper, options *PrimitivePutLongOptions) (PrimitivePutLongResponse, error) {
	req, err := client.putLongCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutLongResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutLongResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutLongResponse{}, client.putLongHandleError(resp)
	}
	return PrimitivePutLongResponse{RawResponse: resp}, nil
}
PutLong - Put complex types with long properties
If the operation fails it returns the *Error error type.
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 PrimitiveClient struct {
	con *Connection
}
func NewPrimitiveClient(con *Connection) *PrimitiveClient {
	return &PrimitiveClient{con: con}
}
func (client *PrimitiveClient) GetBool(ctx context.Context, options *PrimitiveGetBoolOptions) (PrimitiveGetBoolResponse, error) {
	req, err := client.getBoolCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetBoolResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetBoolResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetBoolResponse{}, client.getBoolHandleError(resp)
	}
	return client.getBoolHandleResponse(resp)
}
func (client *PrimitiveClient) getBoolCreateRequest(ctx context.Context, options *PrimitiveGetBoolOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/bool"
	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 *PrimitiveClient) getBoolHandleResponse(resp *http.Response) (PrimitiveGetBoolResponse, error) {
	result := PrimitiveGetBoolResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.BooleanWrapper); err != nil {
		return PrimitiveGetBoolResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getBoolHandleError(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 *PrimitiveClient) GetByte(ctx context.Context, options *PrimitiveGetByteOptions) (PrimitiveGetByteResponse, error) {
	req, err := client.getByteCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetByteResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetByteResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetByteResponse{}, client.getByteHandleError(resp)
	}
	return client.getByteHandleResponse(resp)
}
func (client *PrimitiveClient) getByteCreateRequest(ctx context.Context, options *PrimitiveGetByteOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/byte"
	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 *PrimitiveClient) getByteHandleResponse(resp *http.Response) (PrimitiveGetByteResponse, error) {
	result := PrimitiveGetByteResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ByteWrapper); err != nil {
		return PrimitiveGetByteResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getByteHandleError(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 *PrimitiveClient) GetDate(ctx context.Context, options *PrimitiveGetDateOptions) (PrimitiveGetDateResponse, error) {
	req, err := client.getDateCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetDateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetDateResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetDateResponse{}, client.getDateHandleError(resp)
	}
	return client.getDateHandleResponse(resp)
}
func (client *PrimitiveClient) getDateCreateRequest(ctx context.Context, options *PrimitiveGetDateOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/date"
	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 *PrimitiveClient) getDateHandleResponse(resp *http.Response) (PrimitiveGetDateResponse, error) {
	result := PrimitiveGetDateResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.DateWrapper); err != nil {
		return PrimitiveGetDateResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getDateHandleError(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 *PrimitiveClient) GetDateTime(ctx context.Context, options *PrimitiveGetDateTimeOptions) (PrimitiveGetDateTimeResponse, error) {
	req, err := client.getDateTimeCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetDateTimeResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetDateTimeResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetDateTimeResponse{}, client.getDateTimeHandleError(resp)
	}
	return client.getDateTimeHandleResponse(resp)
}
func (client *PrimitiveClient) getDateTimeCreateRequest(ctx context.Context, options *PrimitiveGetDateTimeOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/datetime"
	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 *PrimitiveClient) getDateTimeHandleResponse(resp *http.Response) (PrimitiveGetDateTimeResponse, error) {
	result := PrimitiveGetDateTimeResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.DatetimeWrapper); err != nil {
		return PrimitiveGetDateTimeResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getDateTimeHandleError(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 *PrimitiveClient) GetDateTimeRFC1123(ctx context.Context, options *PrimitiveGetDateTimeRFC1123Options) (PrimitiveGetDateTimeRFC1123Response, error) {
	req, err := client.getDateTimeRFC1123CreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetDateTimeRFC1123Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetDateTimeRFC1123Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetDateTimeRFC1123Response{}, client.getDateTimeRFC1123HandleError(resp)
	}
	return client.getDateTimeRFC1123HandleResponse(resp)
}
func (client *PrimitiveClient) getDateTimeRFC1123CreateRequest(ctx context.Context, options *PrimitiveGetDateTimeRFC1123Options) (*policy.Request, error) {
	urlPath := "/complex/primitive/datetimerfc1123"
	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 *PrimitiveClient) getDateTimeRFC1123HandleResponse(resp *http.Response) (PrimitiveGetDateTimeRFC1123Response, error) {
	result := PrimitiveGetDateTimeRFC1123Response{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Datetimerfc1123Wrapper); err != nil {
		return PrimitiveGetDateTimeRFC1123Response{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getDateTimeRFC1123HandleError(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 *PrimitiveClient) GetDouble(ctx context.Context, options *PrimitiveGetDoubleOptions) (PrimitiveGetDoubleResponse, error) {
	req, err := client.getDoubleCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetDoubleResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetDoubleResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetDoubleResponse{}, client.getDoubleHandleError(resp)
	}
	return client.getDoubleHandleResponse(resp)
}
func (client *PrimitiveClient) getDoubleCreateRequest(ctx context.Context, options *PrimitiveGetDoubleOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/double"
	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 *PrimitiveClient) getDoubleHandleResponse(resp *http.Response) (PrimitiveGetDoubleResponse, error) {
	result := PrimitiveGetDoubleResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.DoubleWrapper); err != nil {
		return PrimitiveGetDoubleResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getDoubleHandleError(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 *PrimitiveClient) GetDuration(ctx context.Context, options *PrimitiveGetDurationOptions) (PrimitiveGetDurationResponse, error) {
	req, err := client.getDurationCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetDurationResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetDurationResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetDurationResponse{}, client.getDurationHandleError(resp)
	}
	return client.getDurationHandleResponse(resp)
}
func (client *PrimitiveClient) getDurationCreateRequest(ctx context.Context, options *PrimitiveGetDurationOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/duration"
	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 *PrimitiveClient) getDurationHandleResponse(resp *http.Response) (PrimitiveGetDurationResponse, error) {
	result := PrimitiveGetDurationResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.DurationWrapper); err != nil {
		return PrimitiveGetDurationResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getDurationHandleError(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 *PrimitiveClient) GetFloat(ctx context.Context, options *PrimitiveGetFloatOptions) (PrimitiveGetFloatResponse, error) {
	req, err := client.getFloatCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetFloatResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetFloatResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetFloatResponse{}, client.getFloatHandleError(resp)
	}
	return client.getFloatHandleResponse(resp)
}
func (client *PrimitiveClient) getFloatCreateRequest(ctx context.Context, options *PrimitiveGetFloatOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/float"
	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 *PrimitiveClient) getFloatHandleResponse(resp *http.Response) (PrimitiveGetFloatResponse, error) {
	result := PrimitiveGetFloatResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.FloatWrapper); err != nil {
		return PrimitiveGetFloatResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getFloatHandleError(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 *PrimitiveClient) GetInt(ctx context.Context, options *PrimitiveGetIntOptions) (PrimitiveGetIntResponse, error) {
	req, err := client.getIntCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetIntResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetIntResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetIntResponse{}, client.getIntHandleError(resp)
	}
	return client.getIntHandleResponse(resp)
}
func (client *PrimitiveClient) getIntCreateRequest(ctx context.Context, options *PrimitiveGetIntOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/integer"
	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 *PrimitiveClient) getIntHandleResponse(resp *http.Response) (PrimitiveGetIntResponse, error) {
	result := PrimitiveGetIntResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.IntWrapper); err != nil {
		return PrimitiveGetIntResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getIntHandleError(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 *PrimitiveClient) GetLong(ctx context.Context, options *PrimitiveGetLongOptions) (PrimitiveGetLongResponse, error) {
	req, err := client.getLongCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetLongResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetLongResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetLongResponse{}, client.getLongHandleError(resp)
	}
	return client.getLongHandleResponse(resp)
}
func (client *PrimitiveClient) getLongCreateRequest(ctx context.Context, options *PrimitiveGetLongOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/long"
	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 *PrimitiveClient) getLongHandleResponse(resp *http.Response) (PrimitiveGetLongResponse, error) {
	result := PrimitiveGetLongResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.LongWrapper); err != nil {
		return PrimitiveGetLongResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getLongHandleError(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 *PrimitiveClient) GetString(ctx context.Context, options *PrimitiveGetStringOptions) (PrimitiveGetStringResponse, error) {
	req, err := client.getStringCreateRequest(ctx, options)
	if err != nil {
		return PrimitiveGetStringResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitiveGetStringResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitiveGetStringResponse{}, client.getStringHandleError(resp)
	}
	return client.getStringHandleResponse(resp)
}
func (client *PrimitiveClient) getStringCreateRequest(ctx context.Context, options *PrimitiveGetStringOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/string"
	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 *PrimitiveClient) getStringHandleResponse(resp *http.Response) (PrimitiveGetStringResponse, error) {
	result := PrimitiveGetStringResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.StringWrapper); err != nil {
		return PrimitiveGetStringResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PrimitiveClient) getStringHandleError(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 *PrimitiveClient) PutBool(ctx context.Context, complexBody BooleanWrapper, options *PrimitivePutBoolOptions) (PrimitivePutBoolResponse, error) {
	req, err := client.putBoolCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutBoolResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutBoolResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutBoolResponse{}, client.putBoolHandleError(resp)
	}
	return PrimitivePutBoolResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putBoolCreateRequest(ctx context.Context, complexBody BooleanWrapper, options *PrimitivePutBoolOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/bool"
	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)
}
func (client *PrimitiveClient) putBoolHandleError(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 *PrimitiveClient) PutByte(ctx context.Context, complexBody ByteWrapper, options *PrimitivePutByteOptions) (PrimitivePutByteResponse, error) {
	req, err := client.putByteCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutByteResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutByteResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutByteResponse{}, client.putByteHandleError(resp)
	}
	return PrimitivePutByteResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putByteCreateRequest(ctx context.Context, complexBody ByteWrapper, options *PrimitivePutByteOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/byte"
	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)
}
func (client *PrimitiveClient) putByteHandleError(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 *PrimitiveClient) PutDate(ctx context.Context, complexBody DateWrapper, options *PrimitivePutDateOptions) (PrimitivePutDateResponse, error) {
	req, err := client.putDateCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutDateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutDateResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutDateResponse{}, client.putDateHandleError(resp)
	}
	return PrimitivePutDateResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putDateCreateRequest(ctx context.Context, complexBody DateWrapper, options *PrimitivePutDateOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/date"
	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)
}
func (client *PrimitiveClient) putDateHandleError(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 *PrimitiveClient) PutDateTime(ctx context.Context, complexBody DatetimeWrapper, options *PrimitivePutDateTimeOptions) (PrimitivePutDateTimeResponse, error) {
	req, err := client.putDateTimeCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutDateTimeResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutDateTimeResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutDateTimeResponse{}, client.putDateTimeHandleError(resp)
	}
	return PrimitivePutDateTimeResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putDateTimeCreateRequest(ctx context.Context, complexBody DatetimeWrapper, options *PrimitivePutDateTimeOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/datetime"
	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)
}
func (client *PrimitiveClient) putDateTimeHandleError(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 *PrimitiveClient) PutDateTimeRFC1123(ctx context.Context, complexBody Datetimerfc1123Wrapper, options *PrimitivePutDateTimeRFC1123Options) (PrimitivePutDateTimeRFC1123Response, error) {
	req, err := client.putDateTimeRFC1123CreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutDateTimeRFC1123Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutDateTimeRFC1123Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutDateTimeRFC1123Response{}, client.putDateTimeRFC1123HandleError(resp)
	}
	return PrimitivePutDateTimeRFC1123Response{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putDateTimeRFC1123CreateRequest(ctx context.Context, complexBody Datetimerfc1123Wrapper, options *PrimitivePutDateTimeRFC1123Options) (*policy.Request, error) {
	urlPath := "/complex/primitive/datetimerfc1123"
	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)
}
func (client *PrimitiveClient) putDateTimeRFC1123HandleError(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 *PrimitiveClient) PutDouble(ctx context.Context, complexBody DoubleWrapper, options *PrimitivePutDoubleOptions) (PrimitivePutDoubleResponse, error) {
	req, err := client.putDoubleCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutDoubleResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutDoubleResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutDoubleResponse{}, client.putDoubleHandleError(resp)
	}
	return PrimitivePutDoubleResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putDoubleCreateRequest(ctx context.Context, complexBody DoubleWrapper, options *PrimitivePutDoubleOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/double"
	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)
}
func (client *PrimitiveClient) putDoubleHandleError(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 *PrimitiveClient) PutDuration(ctx context.Context, complexBody DurationWrapper, options *PrimitivePutDurationOptions) (PrimitivePutDurationResponse, error) {
	req, err := client.putDurationCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutDurationResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutDurationResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutDurationResponse{}, client.putDurationHandleError(resp)
	}
	return PrimitivePutDurationResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putDurationCreateRequest(ctx context.Context, complexBody DurationWrapper, options *PrimitivePutDurationOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/duration"
	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)
}
func (client *PrimitiveClient) putDurationHandleError(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 *PrimitiveClient) PutFloat(ctx context.Context, complexBody FloatWrapper, options *PrimitivePutFloatOptions) (PrimitivePutFloatResponse, error) {
	req, err := client.putFloatCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutFloatResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutFloatResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutFloatResponse{}, client.putFloatHandleError(resp)
	}
	return PrimitivePutFloatResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putFloatCreateRequest(ctx context.Context, complexBody FloatWrapper, options *PrimitivePutFloatOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/float"
	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)
}
func (client *PrimitiveClient) putFloatHandleError(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 *PrimitiveClient) PutInt(ctx context.Context, complexBody IntWrapper, options *PrimitivePutIntOptions) (PrimitivePutIntResponse, error) {
	req, err := client.putIntCreateRequest(ctx, complexBody, options)
	if err != nil {
		return PrimitivePutIntResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PrimitivePutIntResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PrimitivePutIntResponse{}, client.putIntHandleError(resp)
	}
	return PrimitivePutIntResponse{RawResponse: resp}, nil
}
func (client *PrimitiveClient) putIntCreateRequest(ctx context.Context, complexBody IntWrapper, options *PrimitivePutIntOptions) (*policy.Request, error) {
	urlPath := "/complex/primitive/integer"
	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)
}
func (client *PrimitiveClient) putIntHandleError(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)
}