func (client *DictionaryClient) getDateInvalidNullCreateRequest(ctx context.Context, options *DictionaryGetDateInvalidNullOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/date/invalidnull"
	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
}
getDateInvalidNullCreateRequest creates the GetDateInvalidNull request.
package dictionarygroup
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 DictionaryClient struct {
	con *Connection
}
func NewDictionaryClient(con *Connection) *DictionaryClient {
	return &DictionaryClient{con: con}
}
func (client *DictionaryClient) GetArrayEmpty(ctx context.Context, options *DictionaryGetArrayEmptyOptions) (DictionaryGetArrayEmptyResponse, error) {
	req, err := client.getArrayEmptyCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetArrayEmptyResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetArrayEmptyResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetArrayEmptyResponse{}, client.getArrayEmptyHandleError(resp)
	}
	return client.getArrayEmptyHandleResponse(resp)
}
func (client *DictionaryClient) getArrayEmptyCreateRequest(ctx context.Context, options *DictionaryGetArrayEmptyOptions) (*policy.Request, error) {
	urlPath := "/dictionary/array/empty"
	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 *DictionaryClient) getArrayEmptyHandleResponse(resp *http.Response) (DictionaryGetArrayEmptyResponse, error) {
	result := DictionaryGetArrayEmptyResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetArrayEmptyResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getArrayEmptyHandleError(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 *DictionaryClient) GetArrayItemEmpty(ctx context.Context, options *DictionaryGetArrayItemEmptyOptions) (DictionaryGetArrayItemEmptyResponse, error) {
	req, err := client.getArrayItemEmptyCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetArrayItemEmptyResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetArrayItemEmptyResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetArrayItemEmptyResponse{}, client.getArrayItemEmptyHandleError(resp)
	}
	return client.getArrayItemEmptyHandleResponse(resp)
}
func (client *DictionaryClient) getArrayItemEmptyCreateRequest(ctx context.Context, options *DictionaryGetArrayItemEmptyOptions) (*policy.Request, error) {
	urlPath := "/dictionary/array/itemempty"
	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 *DictionaryClient) getArrayItemEmptyHandleResponse(resp *http.Response) (DictionaryGetArrayItemEmptyResponse, error) {
	result := DictionaryGetArrayItemEmptyResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetArrayItemEmptyResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getArrayItemEmptyHandleError(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 *DictionaryClient) GetArrayItemNull(ctx context.Context, options *DictionaryGetArrayItemNullOptions) (DictionaryGetArrayItemNullResponse, error) {
	req, err := client.getArrayItemNullCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetArrayItemNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetArrayItemNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetArrayItemNullResponse{}, client.getArrayItemNullHandleError(resp)
	}
	return client.getArrayItemNullHandleResponse(resp)
}
func (client *DictionaryClient) getArrayItemNullCreateRequest(ctx context.Context, options *DictionaryGetArrayItemNullOptions) (*policy.Request, error) {
	urlPath := "/dictionary/array/itemnull"
	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 *DictionaryClient) getArrayItemNullHandleResponse(resp *http.Response) (DictionaryGetArrayItemNullResponse, error) {
	result := DictionaryGetArrayItemNullResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetArrayItemNullResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getArrayItemNullHandleError(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 *DictionaryClient) GetArrayNull(ctx context.Context, options *DictionaryGetArrayNullOptions) (DictionaryGetArrayNullResponse, error) {
	req, err := client.getArrayNullCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetArrayNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetArrayNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetArrayNullResponse{}, client.getArrayNullHandleError(resp)
	}
	return client.getArrayNullHandleResponse(resp)
}
func (client *DictionaryClient) getArrayNullCreateRequest(ctx context.Context, options *DictionaryGetArrayNullOptions) (*policy.Request, error) {
	urlPath := "/dictionary/array/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 *DictionaryClient) getArrayNullHandleResponse(resp *http.Response) (DictionaryGetArrayNullResponse, error) {
	result := DictionaryGetArrayNullResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetArrayNullResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getArrayNullHandleError(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 *DictionaryClient) GetArrayValid(ctx context.Context, options *DictionaryGetArrayValidOptions) (DictionaryGetArrayValidResponse, error) {
	req, err := client.getArrayValidCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetArrayValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetArrayValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetArrayValidResponse{}, client.getArrayValidHandleError(resp)
	}
	return client.getArrayValidHandleResponse(resp)
}
func (client *DictionaryClient) getArrayValidCreateRequest(ctx context.Context, options *DictionaryGetArrayValidOptions) (*policy.Request, error) {
	urlPath := "/dictionary/array/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 *DictionaryClient) getArrayValidHandleResponse(resp *http.Response) (DictionaryGetArrayValidResponse, error) {
	result := DictionaryGetArrayValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetArrayValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getArrayValidHandleError(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 *DictionaryClient) GetBase64URL(ctx context.Context, options *DictionaryGetBase64URLOptions) (DictionaryGetBase64URLResponse, error) {
	req, err := client.getBase64URLCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetBase64URLResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetBase64URLResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetBase64URLResponse{}, client.getBase64URLHandleError(resp)
	}
	return client.getBase64URLHandleResponse(resp)
}
func (client *DictionaryClient) getBase64URLCreateRequest(ctx context.Context, options *DictionaryGetBase64URLOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/base64url/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 *DictionaryClient) getBase64URLHandleResponse(resp *http.Response) (DictionaryGetBase64URLResponse, error) {
	result := DictionaryGetBase64URLResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetBase64URLResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getBase64URLHandleError(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 *DictionaryClient) GetBooleanInvalidNull(ctx context.Context, options *DictionaryGetBooleanInvalidNullOptions) (DictionaryGetBooleanInvalidNullResponse, error) {
	req, err := client.getBooleanInvalidNullCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetBooleanInvalidNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetBooleanInvalidNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetBooleanInvalidNullResponse{}, client.getBooleanInvalidNullHandleError(resp)
	}
	return client.getBooleanInvalidNullHandleResponse(resp)
}
func (client *DictionaryClient) getBooleanInvalidNullCreateRequest(ctx context.Context, options *DictionaryGetBooleanInvalidNullOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/boolean/true.null.false"
	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 *DictionaryClient) getBooleanInvalidNullHandleResponse(resp *http.Response) (DictionaryGetBooleanInvalidNullResponse, error) {
	result := DictionaryGetBooleanInvalidNullResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetBooleanInvalidNullResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getBooleanInvalidNullHandleError(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 *DictionaryClient) GetBooleanInvalidString(ctx context.Context, options *DictionaryGetBooleanInvalidStringOptions) (DictionaryGetBooleanInvalidStringResponse, error) {
	req, err := client.getBooleanInvalidStringCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetBooleanInvalidStringResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetBooleanInvalidStringResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetBooleanInvalidStringResponse{}, client.getBooleanInvalidStringHandleError(resp)
	}
	return client.getBooleanInvalidStringHandleResponse(resp)
}
func (client *DictionaryClient) getBooleanInvalidStringCreateRequest(ctx context.Context, options *DictionaryGetBooleanInvalidStringOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/boolean/true.boolean.false"
	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 *DictionaryClient) getBooleanInvalidStringHandleResponse(resp *http.Response) (DictionaryGetBooleanInvalidStringResponse, error) {
	result := DictionaryGetBooleanInvalidStringResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetBooleanInvalidStringResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getBooleanInvalidStringHandleError(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 *DictionaryClient) GetBooleanTfft(ctx context.Context, options *DictionaryGetBooleanTfftOptions) (DictionaryGetBooleanTfftResponse, error) {
	req, err := client.getBooleanTfftCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetBooleanTfftResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetBooleanTfftResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetBooleanTfftResponse{}, client.getBooleanTfftHandleError(resp)
	}
	return client.getBooleanTfftHandleResponse(resp)
}
func (client *DictionaryClient) getBooleanTfftCreateRequest(ctx context.Context, options *DictionaryGetBooleanTfftOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/boolean/tfft"
	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 *DictionaryClient) getBooleanTfftHandleResponse(resp *http.Response) (DictionaryGetBooleanTfftResponse, error) {
	result := DictionaryGetBooleanTfftResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetBooleanTfftResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getBooleanTfftHandleError(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 *DictionaryClient) GetByteInvalidNull(ctx context.Context, options *DictionaryGetByteInvalidNullOptions) (DictionaryGetByteInvalidNullResponse, error) {
	req, err := client.getByteInvalidNullCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetByteInvalidNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetByteInvalidNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetByteInvalidNullResponse{}, client.getByteInvalidNullHandleError(resp)
	}
	return client.getByteInvalidNullHandleResponse(resp)
}
func (client *DictionaryClient) getByteInvalidNullCreateRequest(ctx context.Context, options *DictionaryGetByteInvalidNullOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/byte/invalidnull"
	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 *DictionaryClient) getByteInvalidNullHandleResponse(resp *http.Response) (DictionaryGetByteInvalidNullResponse, error) {
	result := DictionaryGetByteInvalidNullResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetByteInvalidNullResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getByteInvalidNullHandleError(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 *DictionaryClient) GetByteValid(ctx context.Context, options *DictionaryGetByteValidOptions) (DictionaryGetByteValidResponse, error) {
	req, err := client.getByteValidCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetByteValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetByteValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetByteValidResponse{}, client.getByteValidHandleError(resp)
	}
	return client.getByteValidHandleResponse(resp)
}
func (client *DictionaryClient) getByteValidCreateRequest(ctx context.Context, options *DictionaryGetByteValidOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/byte/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 *DictionaryClient) getByteValidHandleResponse(resp *http.Response) (DictionaryGetByteValidResponse, error) {
	result := DictionaryGetByteValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetByteValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getByteValidHandleError(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 *DictionaryClient) GetComplexEmpty(ctx context.Context, options *DictionaryGetComplexEmptyOptions) (DictionaryGetComplexEmptyResponse, error) {
	req, err := client.getComplexEmptyCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetComplexEmptyResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetComplexEmptyResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetComplexEmptyResponse{}, client.getComplexEmptyHandleError(resp)
	}
	return client.getComplexEmptyHandleResponse(resp)
}
func (client *DictionaryClient) getComplexEmptyCreateRequest(ctx context.Context, options *DictionaryGetComplexEmptyOptions) (*policy.Request, error) {
	urlPath := "/dictionary/complex/empty"
	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 *DictionaryClient) getComplexEmptyHandleResponse(resp *http.Response) (DictionaryGetComplexEmptyResponse, error) {
	result := DictionaryGetComplexEmptyResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetComplexEmptyResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getComplexEmptyHandleError(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 *DictionaryClient) GetComplexItemEmpty(ctx context.Context, options *DictionaryGetComplexItemEmptyOptions) (DictionaryGetComplexItemEmptyResponse, error) {
	req, err := client.getComplexItemEmptyCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetComplexItemEmptyResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetComplexItemEmptyResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetComplexItemEmptyResponse{}, client.getComplexItemEmptyHandleError(resp)
	}
	return client.getComplexItemEmptyHandleResponse(resp)
}
func (client *DictionaryClient) getComplexItemEmptyCreateRequest(ctx context.Context, options *DictionaryGetComplexItemEmptyOptions) (*policy.Request, error) {
	urlPath := "/dictionary/complex/itemempty"
	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 *DictionaryClient) getComplexItemEmptyHandleResponse(resp *http.Response) (DictionaryGetComplexItemEmptyResponse, error) {
	result := DictionaryGetComplexItemEmptyResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetComplexItemEmptyResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getComplexItemEmptyHandleError(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 *DictionaryClient) GetComplexItemNull(ctx context.Context, options *DictionaryGetComplexItemNullOptions) (DictionaryGetComplexItemNullResponse, error) {
	req, err := client.getComplexItemNullCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetComplexItemNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetComplexItemNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetComplexItemNullResponse{}, client.getComplexItemNullHandleError(resp)
	}
	return client.getComplexItemNullHandleResponse(resp)
}
func (client *DictionaryClient) getComplexItemNullCreateRequest(ctx context.Context, options *DictionaryGetComplexItemNullOptions) (*policy.Request, error) {
	urlPath := "/dictionary/complex/itemnull"
	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 *DictionaryClient) getComplexItemNullHandleResponse(resp *http.Response) (DictionaryGetComplexItemNullResponse, error) {
	result := DictionaryGetComplexItemNullResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetComplexItemNullResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getComplexItemNullHandleError(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 *DictionaryClient) GetComplexNull(ctx context.Context, options *DictionaryGetComplexNullOptions) (DictionaryGetComplexNullResponse, error) {
	req, err := client.getComplexNullCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetComplexNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetComplexNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetComplexNullResponse{}, client.getComplexNullHandleError(resp)
	}
	return client.getComplexNullHandleResponse(resp)
}
func (client *DictionaryClient) getComplexNullCreateRequest(ctx context.Context, options *DictionaryGetComplexNullOptions) (*policy.Request, error) {
	urlPath := "/dictionary/complex/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 *DictionaryClient) getComplexNullHandleResponse(resp *http.Response) (DictionaryGetComplexNullResponse, error) {
	result := DictionaryGetComplexNullResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetComplexNullResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getComplexNullHandleError(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 *DictionaryClient) GetComplexValid(ctx context.Context, options *DictionaryGetComplexValidOptions) (DictionaryGetComplexValidResponse, error) {
	req, err := client.getComplexValidCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetComplexValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetComplexValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetComplexValidResponse{}, client.getComplexValidHandleError(resp)
	}
	return client.getComplexValidHandleResponse(resp)
}
func (client *DictionaryClient) getComplexValidCreateRequest(ctx context.Context, options *DictionaryGetComplexValidOptions) (*policy.Request, error) {
	urlPath := "/dictionary/complex/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 *DictionaryClient) getComplexValidHandleResponse(resp *http.Response) (DictionaryGetComplexValidResponse, error) {
	result := DictionaryGetComplexValidResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return DictionaryGetComplexValidResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *DictionaryClient) getComplexValidHandleError(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 *DictionaryClient) GetDateInvalidChars(ctx context.Context, options *DictionaryGetDateInvalidCharsOptions) (DictionaryGetDateInvalidCharsResponse, error) {
	req, err := client.getDateInvalidCharsCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetDateInvalidCharsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetDateInvalidCharsResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetDateInvalidCharsResponse{}, client.getDateInvalidCharsHandleError(resp)
	}
	return client.getDateInvalidCharsHandleResponse(resp)
}
func (client *DictionaryClient) getDateInvalidCharsCreateRequest(ctx context.Context, options *DictionaryGetDateInvalidCharsOptions) (*policy.Request, error) {
	urlPath := "/dictionary/prim/date/invalidchars"
	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 *DictionaryClient) getDateInvalidCharsHandleResponse(resp *http.Response) (DictionaryGetDateInvalidCharsResponse, error) {
	result := DictionaryGetDateInvalidCharsResponse{RawResponse: resp}
	aux := map[string]*dateType{}
	if err := runtime.UnmarshalAsJSON(resp, &aux); err != nil {
		return DictionaryGetDateInvalidCharsResponse{}, runtime.NewResponseError(err, resp)
	}
	cp := map[string]*time.Time{}
	for k, v := range aux {
		cp[k] = (*time.Time)(v)
	}
	result.Value = cp
	return result, nil
}
func (client *DictionaryClient) getDateInvalidCharsHandleError(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 *DictionaryClient) GetDateInvalidNull(ctx context.Context, options *DictionaryGetDateInvalidNullOptions) (DictionaryGetDateInvalidNullResponse, error) {
	req, err := client.getDateInvalidNullCreateRequest(ctx, options)
	if err != nil {
		return DictionaryGetDateInvalidNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return DictionaryGetDateInvalidNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return DictionaryGetDateInvalidNullResponse{}, client.getDateInvalidNullHandleError(resp)
	}
	return client.getDateInvalidNullHandleResponse(resp)
}