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)
}
GetLong - Get 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)
}