func (client *ExplicitClient) PostOptionalClassParameter(ctx context.Context, options *ExplicitPostOptionalClassParameterOptions) (ExplicitPostOptionalClassParameterResponse, error) {
	req, err := client.postOptionalClassParameterCreateRequest(ctx, options)
	if err != nil {
		return ExplicitPostOptionalClassParameterResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return ExplicitPostOptionalClassParameterResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return ExplicitPostOptionalClassParameterResponse{}, client.postOptionalClassParameterHandleError(resp)
	}
	return ExplicitPostOptionalClassParameterResponse{RawResponse: resp}, nil
}
PostOptionalClassParameter - Test explicitly optional complex object. Please put null.
If the operation fails it returns the *Error error type.
package optionalgroup
import (
	"context"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"io"
	"net/http"
	"strconv"
	"strings"
)
type ExplicitClient struct {
	con *Connection
}
func NewExplicitClient(con *Connection) *ExplicitClient {
	return &ExplicitClient{con: con}
}
func (client *ExplicitClient) PostOptionalArrayHeader(ctx context.Context, options *ExplicitPostOptionalArrayHeaderOptions) (ExplicitPostOptionalArrayHeaderResponse, error) {
	req, err := client.postOptionalArrayHeaderCreateRequest(ctx, options)
	if err != nil {
		return ExplicitPostOptionalArrayHeaderResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return ExplicitPostOptionalArrayHeaderResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return ExplicitPostOptionalArrayHeaderResponse{}, client.postOptionalArrayHeaderHandleError(resp)
	}
	return ExplicitPostOptionalArrayHeaderResponse{RawResponse: resp}, nil
}
func (client *ExplicitClient) postOptionalArrayHeaderCreateRequest(ctx context.Context, options *ExplicitPostOptionalArrayHeaderOptions) (*policy.Request, error) {
	urlPath := "/reqopt/optional/array/header"
	req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	if options != nil && options.HeaderParameter != nil {
		req.Raw().Header.Set("headerParameter", strings.Join(options.HeaderParameter, ","))
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *ExplicitClient) postOptionalArrayHeaderHandleError(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 *ExplicitClient) PostOptionalArrayParameter(ctx context.Context, options *ExplicitPostOptionalArrayParameterOptions) (ExplicitPostOptionalArrayParameterResponse, error) {
	req, err := client.postOptionalArrayParameterCreateRequest(ctx, options)
	if err != nil {
		return ExplicitPostOptionalArrayParameterResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return ExplicitPostOptionalArrayParameterResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return ExplicitPostOptionalArrayParameterResponse{}, client.postOptionalArrayParameterHandleError(resp)
	}
	return ExplicitPostOptionalArrayParameterResponse{RawResponse: resp}, nil
}
func (client *ExplicitClient) postOptionalArrayParameterCreateRequest(ctx context.Context, options *ExplicitPostOptionalArrayParameterOptions) (*policy.Request, error) {
	urlPath := "/reqopt/optional/array/parameter"
	req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	if options != nil && options.BodyParameter != nil {
		return req, runtime.MarshalAsJSON(req, options.BodyParameter)
	}
	return req, nil
}
func (client *ExplicitClient) postOptionalArrayParameterHandleError(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 *ExplicitClient) PostOptionalArrayProperty(ctx context.Context, options *ExplicitPostOptionalArrayPropertyOptions) (ExplicitPostOptionalArrayPropertyResponse, error) {
	req, err := client.postOptionalArrayPropertyCreateRequest(ctx, options)
	if err != nil {
		return ExplicitPostOptionalArrayPropertyResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return ExplicitPostOptionalArrayPropertyResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return ExplicitPostOptionalArrayPropertyResponse{}, client.postOptionalArrayPropertyHandleError(resp)
	}
	return ExplicitPostOptionalArrayPropertyResponse{RawResponse: resp}, nil
}
func (client *ExplicitClient) postOptionalArrayPropertyCreateRequest(ctx context.Context, options *ExplicitPostOptionalArrayPropertyOptions) (*policy.Request, error) {
	urlPath := "/reqopt/optional/array/property"
	req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	if options != nil && options.BodyParameter != nil {
		return req, runtime.MarshalAsJSON(req, *options.BodyParameter)
	}
	return req, nil
}
func (client *ExplicitClient) postOptionalArrayPropertyHandleError(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)
}