func (client *IntClient) putUnixTimeDateCreateRequest(ctx context.Context, intBody time.Time, options *IntPutUnixTimeDateOptions) (*policy.Request, error) {
	urlPath := "/int/unixtime"
	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")
	aux := timeUnix(intBody)
	return req, runtime.MarshalAsJSON(req, aux)
}
putUnixTimeDateCreateRequest creates the PutUnixTimeDate request.
package integergroup
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"
	"time"
)
type IntClient struct {
	con *Connection
}
func NewIntClient(con *Connection) *IntClient {
	return &IntClient{con: con}
}
func (client *IntClient) GetInvalid(ctx context.Context, options *IntGetInvalidOptions) (IntGetInvalidResponse, error) {
	req, err := client.getInvalidCreateRequest(ctx, options)
	if err != nil {
		return IntGetInvalidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetInvalidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetInvalidResponse{}, client.getInvalidHandleError(resp)
	}
	return client.getInvalidHandleResponse(resp)
}
func (client *IntClient) getInvalidCreateRequest(ctx context.Context, options *IntGetInvalidOptions) (*policy.Request, error) {
	urlPath := "/int/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 *IntClient) getInvalidHandleResponse(resp *http.Response) (IntGetInvalidResponse, error) {
	result := IntGetInvalidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return IntGetInvalidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *IntClient) getInvalidHandleError(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 *IntClient) GetInvalidUnixTime(ctx context.Context, options *IntGetInvalidUnixTimeOptions) (IntGetInvalidUnixTimeResponse, error) {
	req, err := client.getInvalidUnixTimeCreateRequest(ctx, options)
	if err != nil {
		return IntGetInvalidUnixTimeResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetInvalidUnixTimeResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetInvalidUnixTimeResponse{}, client.getInvalidUnixTimeHandleError(resp)
	}
	return client.getInvalidUnixTimeHandleResponse(resp)
}
func (client *IntClient) getInvalidUnixTimeCreateRequest(ctx context.Context, options *IntGetInvalidUnixTimeOptions) (*policy.Request, error) {
	urlPath := "/int/invalidunixtime"
	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 *IntClient) getInvalidUnixTimeHandleResponse(resp *http.Response) (IntGetInvalidUnixTimeResponse, error) {
	result := IntGetInvalidUnixTimeResponse{RawResponse: resp}
	var aux *timeUnix
	if err := runtime.UnmarshalAsJSON(resp, &aux); err != nil {
		return IntGetInvalidUnixTimeResponse{}, runtime.NewResponseError(err, resp)
	}
	result.Value = (*time.Time)(aux)
	return result, nil
}
func (client *IntClient) getInvalidUnixTimeHandleError(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 *IntClient) GetNull(ctx context.Context, options *IntGetNullOptions) (IntGetNullResponse, error) {
	req, err := client.getNullCreateRequest(ctx, options)
	if err != nil {
		return IntGetNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetNullResponse{}, client.getNullHandleError(resp)
	}
	return client.getNullHandleResponse(resp)
}
func (client *IntClient) getNullCreateRequest(ctx context.Context, options *IntGetNullOptions) (*policy.Request, error) {
	urlPath := "/int/null"
	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 *IntClient) getNullHandleResponse(resp *http.Response) (IntGetNullResponse, error) {
	result := IntGetNullResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return IntGetNullResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *IntClient) getNullHandleError(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 *IntClient) GetNullUnixTime(ctx context.Context, options *IntGetNullUnixTimeOptions) (IntGetNullUnixTimeResponse, error) {
	req, err := client.getNullUnixTimeCreateRequest(ctx, options)
	if err != nil {
		return IntGetNullUnixTimeResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetNullUnixTimeResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetNullUnixTimeResponse{}, client.getNullUnixTimeHandleError(resp)
	}
	return client.getNullUnixTimeHandleResponse(resp)
}
func (client *IntClient) getNullUnixTimeCreateRequest(ctx context.Context, options *IntGetNullUnixTimeOptions) (*policy.Request, error) {
	urlPath := "/int/nullunixtime"
	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 *IntClient) getNullUnixTimeHandleResponse(resp *http.Response) (IntGetNullUnixTimeResponse, error) {
	result := IntGetNullUnixTimeResponse{RawResponse: resp}
	var aux *timeUnix
	if err := runtime.UnmarshalAsJSON(resp, &aux); err != nil {
		return IntGetNullUnixTimeResponse{}, runtime.NewResponseError(err, resp)
	}
	result.Value = (*time.Time)(aux)
	return result, nil
}
func (client *IntClient) getNullUnixTimeHandleError(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 *IntClient) GetOverflowInt32(ctx context.Context, options *IntGetOverflowInt32Options) (IntGetOverflowInt32Response, error) {
	req, err := client.getOverflowInt32CreateRequest(ctx, options)
	if err != nil {
		return IntGetOverflowInt32Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetOverflowInt32Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetOverflowInt32Response{}, client.getOverflowInt32HandleError(resp)
	}
	return client.getOverflowInt32HandleResponse(resp)
}
func (client *IntClient) getOverflowInt32CreateRequest(ctx context.Context, options *IntGetOverflowInt32Options) (*policy.Request, error) {
	urlPath := "/int/overflowint32"
	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 *IntClient) getOverflowInt32HandleResponse(resp *http.Response) (IntGetOverflowInt32Response, error) {
	result := IntGetOverflowInt32Response{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return IntGetOverflowInt32Response{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *IntClient) getOverflowInt32HandleError(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 *IntClient) GetOverflowInt64(ctx context.Context, options *IntGetOverflowInt64Options) (IntGetOverflowInt64Response, error) {
	req, err := client.getOverflowInt64CreateRequest(ctx, options)
	if err != nil {
		return IntGetOverflowInt64Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetOverflowInt64Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetOverflowInt64Response{}, client.getOverflowInt64HandleError(resp)
	}
	return client.getOverflowInt64HandleResponse(resp)
}
func (client *IntClient) getOverflowInt64CreateRequest(ctx context.Context, options *IntGetOverflowInt64Options) (*policy.Request, error) {
	urlPath := "/int/overflowint64"
	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 *IntClient) getOverflowInt64HandleResponse(resp *http.Response) (IntGetOverflowInt64Response, error) {
	result := IntGetOverflowInt64Response{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return IntGetOverflowInt64Response{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *IntClient) getOverflowInt64HandleError(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 *IntClient) GetUnderflowInt32(ctx context.Context, options *IntGetUnderflowInt32Options) (IntGetUnderflowInt32Response, error) {
	req, err := client.getUnderflowInt32CreateRequest(ctx, options)
	if err != nil {
		return IntGetUnderflowInt32Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetUnderflowInt32Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetUnderflowInt32Response{}, client.getUnderflowInt32HandleError(resp)
	}
	return client.getUnderflowInt32HandleResponse(resp)
}
func (client *IntClient) getUnderflowInt32CreateRequest(ctx context.Context, options *IntGetUnderflowInt32Options) (*policy.Request, error) {
	urlPath := "/int/underflowint32"
	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 *IntClient) getUnderflowInt32HandleResponse(resp *http.Response) (IntGetUnderflowInt32Response, error) {
	result := IntGetUnderflowInt32Response{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return IntGetUnderflowInt32Response{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *IntClient) getUnderflowInt32HandleError(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 *IntClient) GetUnderflowInt64(ctx context.Context, options *IntGetUnderflowInt64Options) (IntGetUnderflowInt64Response, error) {
	req, err := client.getUnderflowInt64CreateRequest(ctx, options)
	if err != nil {
		return IntGetUnderflowInt64Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetUnderflowInt64Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetUnderflowInt64Response{}, client.getUnderflowInt64HandleError(resp)
	}
	return client.getUnderflowInt64HandleResponse(resp)
}
func (client *IntClient) getUnderflowInt64CreateRequest(ctx context.Context, options *IntGetUnderflowInt64Options) (*policy.Request, error) {
	urlPath := "/int/underflowint64"
	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 *IntClient) getUnderflowInt64HandleResponse(resp *http.Response) (IntGetUnderflowInt64Response, error) {
	result := IntGetUnderflowInt64Response{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return IntGetUnderflowInt64Response{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *IntClient) getUnderflowInt64HandleError(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 *IntClient) GetUnixTime(ctx context.Context, options *IntGetUnixTimeOptions) (IntGetUnixTimeResponse, error) {
	req, err := client.getUnixTimeCreateRequest(ctx, options)
	if err != nil {
		return IntGetUnixTimeResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntGetUnixTimeResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntGetUnixTimeResponse{}, client.getUnixTimeHandleError(resp)
	}
	return client.getUnixTimeHandleResponse(resp)
}
func (client *IntClient) getUnixTimeCreateRequest(ctx context.Context, options *IntGetUnixTimeOptions) (*policy.Request, error) {
	urlPath := "/int/unixtime"
	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 *IntClient) getUnixTimeHandleResponse(resp *http.Response) (IntGetUnixTimeResponse, error) {
	result := IntGetUnixTimeResponse{RawResponse: resp}
	var aux *timeUnix
	if err := runtime.UnmarshalAsJSON(resp, &aux); err != nil {
		return IntGetUnixTimeResponse{}, runtime.NewResponseError(err, resp)
	}
	result.Value = (*time.Time)(aux)
	return result, nil
}
func (client *IntClient) getUnixTimeHandleError(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 *IntClient) PutMax32(ctx context.Context, intBody int32, options *IntPutMax32Options) (IntPutMax32Response, error) {
	req, err := client.putMax32CreateRequest(ctx, intBody, options)
	if err != nil {
		return IntPutMax32Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntPutMax32Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntPutMax32Response{}, client.putMax32HandleError(resp)
	}
	return IntPutMax32Response{RawResponse: resp}, nil
}
func (client *IntClient) putMax32CreateRequest(ctx context.Context, intBody int32, options *IntPutMax32Options) (*policy.Request, error) {
	urlPath := "/int/max/32"
	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, intBody)
}
func (client *IntClient) putMax32HandleError(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 *IntClient) PutMax64(ctx context.Context, intBody int64, options *IntPutMax64Options) (IntPutMax64Response, error) {
	req, err := client.putMax64CreateRequest(ctx, intBody, options)
	if err != nil {
		return IntPutMax64Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntPutMax64Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntPutMax64Response{}, client.putMax64HandleError(resp)
	}
	return IntPutMax64Response{RawResponse: resp}, nil
}
func (client *IntClient) putMax64CreateRequest(ctx context.Context, intBody int64, options *IntPutMax64Options) (*policy.Request, error) {
	urlPath := "/int/max/64"
	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, intBody)
}
func (client *IntClient) putMax64HandleError(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 *IntClient) PutMin32(ctx context.Context, intBody int32, options *IntPutMin32Options) (IntPutMin32Response, error) {
	req, err := client.putMin32CreateRequest(ctx, intBody, options)
	if err != nil {
		return IntPutMin32Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntPutMin32Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntPutMin32Response{}, client.putMin32HandleError(resp)
	}
	return IntPutMin32Response{RawResponse: resp}, nil
}
func (client *IntClient) putMin32CreateRequest(ctx context.Context, intBody int32, options *IntPutMin32Options) (*policy.Request, error) {
	urlPath := "/int/min/32"
	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, intBody)
}
func (client *IntClient) putMin32HandleError(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 *IntClient) PutMin64(ctx context.Context, intBody int64, options *IntPutMin64Options) (IntPutMin64Response, error) {
	req, err := client.putMin64CreateRequest(ctx, intBody, options)
	if err != nil {
		return IntPutMin64Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntPutMin64Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntPutMin64Response{}, client.putMin64HandleError(resp)
	}
	return IntPutMin64Response{RawResponse: resp}, nil
}
func (client *IntClient) putMin64CreateRequest(ctx context.Context, intBody int64, options *IntPutMin64Options) (*policy.Request, error) {
	urlPath := "/int/min/64"
	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, intBody)
}
func (client *IntClient) putMin64HandleError(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 *IntClient) PutUnixTimeDate(ctx context.Context, intBody time.Time, options *IntPutUnixTimeDateOptions) (IntPutUnixTimeDateResponse, error) {
	req, err := client.putUnixTimeDateCreateRequest(ctx, intBody, options)
	if err != nil {
		return IntPutUnixTimeDateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return IntPutUnixTimeDateResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return IntPutUnixTimeDateResponse{}, client.putUnixTimeDateHandleError(resp)
	}
	return IntPutUnixTimeDateResponse{RawResponse: resp}, nil
}