func (client *PathsClient) GetTenBillion(ctx context.Context, options *PathsGetTenBillionOptions) (PathsGetTenBillionResponse, error) {
	req, err := client.getTenBillionCreateRequest(ctx, options)
	if err != nil {
		return PathsGetTenBillionResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsGetTenBillionResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsGetTenBillionResponse{}, client.getTenBillionHandleError(resp)
	}
	return PathsGetTenBillionResponse{RawResponse: resp}, nil
}
GetTenBillion - Get '10000000000' 64 bit integer value
If the operation fails it returns the *Error error type.
package urlgroup
import (
	"context"
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
	"net/url"
	"strings"
	"time"
)
type PathsClient struct {
	con *Connection
}
func NewPathsClient(con *Connection) *PathsClient {
	return &PathsClient{con: con}
}
func (client *PathsClient) ArrayCSVInPath(ctx context.Context, arrayPath []string, options *PathsArrayCSVInPathOptions) (PathsArrayCSVInPathResponse, error) {
	req, err := client.arrayCSVInPathCreateRequest(ctx, arrayPath, options)
	if err != nil {
		return PathsArrayCSVInPathResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsArrayCSVInPathResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsArrayCSVInPathResponse{}, client.arrayCSVInPathHandleError(resp)
	}
	return PathsArrayCSVInPathResponse{RawResponse: resp}, nil
}
func (client *PathsClient) arrayCSVInPathCreateRequest(ctx context.Context, arrayPath []string, options *PathsArrayCSVInPathOptions) (*policy.Request, error) {
	urlPath := "/paths/array/ArrayPath1%2cbegin%21%2A%27%28%29%3B%3A%40%20%26%3D%2B%24%2C%2F%3F%23%5B%5Dend%2c%2c/{arrayPath}"
	urlPath = strings.ReplaceAll(urlPath, "{arrayPath}", url.PathEscape(strings.Join(arrayPath, ",")))
	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 *PathsClient) arrayCSVInPathHandleError(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 *PathsClient) Base64URL(ctx context.Context, base64URLPath []byte, options *PathsBase64URLOptions) (PathsBase64URLResponse, error) {
	req, err := client.base64URLCreateRequest(ctx, base64URLPath, options)
	if err != nil {
		return PathsBase64URLResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsBase64URLResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsBase64URLResponse{}, client.base64URLHandleError(resp)
	}
	return PathsBase64URLResponse{RawResponse: resp}, nil
}
func (client *PathsClient) base64URLCreateRequest(ctx context.Context, base64URLPath []byte, options *PathsBase64URLOptions) (*policy.Request, error) {
	urlPath := "/paths/string/bG9yZW0/{base64UrlPath}"
	urlPath = strings.ReplaceAll(urlPath, "{base64UrlPath}", url.PathEscape(base64.RawURLEncoding.EncodeToString(base64URLPath)))
	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 *PathsClient) base64URLHandleError(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 *PathsClient) ByteEmpty(ctx context.Context, options *PathsByteEmptyOptions) (PathsByteEmptyResponse, error) {
	req, err := client.byteEmptyCreateRequest(ctx, options)
	if err != nil {
		return PathsByteEmptyResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsByteEmptyResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsByteEmptyResponse{}, client.byteEmptyHandleError(resp)
	}
	return PathsByteEmptyResponse{RawResponse: resp}, nil
}
func (client *PathsClient) byteEmptyCreateRequest(ctx context.Context, options *PathsByteEmptyOptions) (*policy.Request, error) {
	urlPath := "/paths/byte/empty/{bytePath}"
	urlPath = strings.ReplaceAll(urlPath, "{bytePath}", url.PathEscape(""))
	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 *PathsClient) byteEmptyHandleError(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 *PathsClient) ByteMultiByte(ctx context.Context, bytePath []byte, options *PathsByteMultiByteOptions) (PathsByteMultiByteResponse, error) {
	req, err := client.byteMultiByteCreateRequest(ctx, bytePath, options)
	if err != nil {
		return PathsByteMultiByteResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsByteMultiByteResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsByteMultiByteResponse{}, client.byteMultiByteHandleError(resp)
	}
	return PathsByteMultiByteResponse{RawResponse: resp}, nil
}
func (client *PathsClient) byteMultiByteCreateRequest(ctx context.Context, bytePath []byte, options *PathsByteMultiByteOptions) (*policy.Request, error) {
	urlPath := "/paths/byte/multibyte/{bytePath}"
	urlPath = strings.ReplaceAll(urlPath, "{bytePath}", url.PathEscape(base64.StdEncoding.EncodeToString(bytePath)))
	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 *PathsClient) byteMultiByteHandleError(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 *PathsClient) ByteNull(ctx context.Context, bytePath []byte, options *PathsByteNullOptions) (PathsByteNullResponse, error) {
	req, err := client.byteNullCreateRequest(ctx, bytePath, options)
	if err != nil {
		return PathsByteNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsByteNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusBadRequest) {
		return PathsByteNullResponse{}, client.byteNullHandleError(resp)
	}
	return PathsByteNullResponse{RawResponse: resp}, nil
}
func (client *PathsClient) byteNullCreateRequest(ctx context.Context, bytePath []byte, options *PathsByteNullOptions) (*policy.Request, error) {
	urlPath := "/paths/byte/null/{bytePath}"
	urlPath = strings.ReplaceAll(urlPath, "{bytePath}", url.PathEscape(base64.StdEncoding.EncodeToString(bytePath)))
	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 *PathsClient) byteNullHandleError(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 *PathsClient) DateNull(ctx context.Context, datePath time.Time, options *PathsDateNullOptions) (PathsDateNullResponse, error) {
	req, err := client.dateNullCreateRequest(ctx, datePath, options)
	if err != nil {
		return PathsDateNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsDateNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusBadRequest) {
		return PathsDateNullResponse{}, client.dateNullHandleError(resp)
	}
	return PathsDateNullResponse{RawResponse: resp}, nil
}
func (client *PathsClient) dateNullCreateRequest(ctx context.Context, datePath time.Time, options *PathsDateNullOptions) (*policy.Request, error) {
	urlPath := "/paths/date/null/{datePath}"
	urlPath = strings.ReplaceAll(urlPath, "{datePath}", url.PathEscape(datePath.Format("2006-01-02")))
	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 *PathsClient) dateNullHandleError(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 *PathsClient) DateTimeNull(ctx context.Context, dateTimePath time.Time, options *PathsDateTimeNullOptions) (PathsDateTimeNullResponse, error) {
	req, err := client.dateTimeNullCreateRequest(ctx, dateTimePath, options)
	if err != nil {
		return PathsDateTimeNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsDateTimeNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusBadRequest) {
		return PathsDateTimeNullResponse{}, client.dateTimeNullHandleError(resp)
	}
	return PathsDateTimeNullResponse{RawResponse: resp}, nil
}
func (client *PathsClient) dateTimeNullCreateRequest(ctx context.Context, dateTimePath time.Time, options *PathsDateTimeNullOptions) (*policy.Request, error) {
	urlPath := "/paths/datetime/null/{dateTimePath}"
	urlPath = strings.ReplaceAll(urlPath, "{dateTimePath}", url.PathEscape(dateTimePath.Format(time.RFC3339Nano)))
	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 *PathsClient) dateTimeNullHandleError(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 *PathsClient) DateTimeValid(ctx context.Context, options *PathsDateTimeValidOptions) (PathsDateTimeValidResponse, error) {
	req, err := client.dateTimeValidCreateRequest(ctx, options)
	if err != nil {
		return PathsDateTimeValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsDateTimeValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsDateTimeValidResponse{}, client.dateTimeValidHandleError(resp)
	}
	return PathsDateTimeValidResponse{RawResponse: resp}, nil
}
func (client *PathsClient) dateTimeValidCreateRequest(ctx context.Context, options *PathsDateTimeValidOptions) (*policy.Request, error) {
	urlPath := "/paths/datetime/2012-01-01T01%3A01%3A01Z/{dateTimePath}"
	urlPath = strings.ReplaceAll(urlPath, "{dateTimePath}", url.PathEscape("2012-01-01T01:01:01Z"))
	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 *PathsClient) dateTimeValidHandleError(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 *PathsClient) DateValid(ctx context.Context, options *PathsDateValidOptions) (PathsDateValidResponse, error) {
	req, err := client.dateValidCreateRequest(ctx, options)
	if err != nil {
		return PathsDateValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsDateValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsDateValidResponse{}, client.dateValidHandleError(resp)
	}
	return PathsDateValidResponse{RawResponse: resp}, nil
}
func (client *PathsClient) dateValidCreateRequest(ctx context.Context, options *PathsDateValidOptions) (*policy.Request, error) {
	urlPath := "/paths/date/2012-01-01/{datePath}"
	urlPath = strings.ReplaceAll(urlPath, "{datePath}", url.PathEscape("2012-01-01"))
	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 *PathsClient) dateValidHandleError(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 *PathsClient) DoubleDecimalNegative(ctx context.Context, options *PathsDoubleDecimalNegativeOptions) (PathsDoubleDecimalNegativeResponse, error) {
	req, err := client.doubleDecimalNegativeCreateRequest(ctx, options)
	if err != nil {
		return PathsDoubleDecimalNegativeResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsDoubleDecimalNegativeResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsDoubleDecimalNegativeResponse{}, client.doubleDecimalNegativeHandleError(resp)
	}
	return PathsDoubleDecimalNegativeResponse{RawResponse: resp}, nil
}
func (client *PathsClient) doubleDecimalNegativeCreateRequest(ctx context.Context, options *PathsDoubleDecimalNegativeOptions) (*policy.Request, error) {
	urlPath := "/paths/double/-9999999.999/{doublePath}"
	urlPath = strings.ReplaceAll(urlPath, "{doublePath}", url.PathEscape("-9999999.999"))
	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 *PathsClient) doubleDecimalNegativeHandleError(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 *PathsClient) DoubleDecimalPositive(ctx context.Context, options *PathsDoubleDecimalPositiveOptions) (PathsDoubleDecimalPositiveResponse, error) {
	req, err := client.doubleDecimalPositiveCreateRequest(ctx, options)
	if err != nil {
		return PathsDoubleDecimalPositiveResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsDoubleDecimalPositiveResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsDoubleDecimalPositiveResponse{}, client.doubleDecimalPositiveHandleError(resp)
	}
	return PathsDoubleDecimalPositiveResponse{RawResponse: resp}, nil
}
func (client *PathsClient) doubleDecimalPositiveCreateRequest(ctx context.Context, options *PathsDoubleDecimalPositiveOptions) (*policy.Request, error) {
	urlPath := "/paths/double/9999999.999/{doublePath}"
	urlPath = strings.ReplaceAll(urlPath, "{doublePath}", url.PathEscape("9999999.999"))
	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 *PathsClient) doubleDecimalPositiveHandleError(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 *PathsClient) EnumNull(ctx context.Context, enumPath URIColor, options *PathsEnumNullOptions) (PathsEnumNullResponse, error) {
	req, err := client.enumNullCreateRequest(ctx, enumPath, options)
	if err != nil {
		return PathsEnumNullResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsEnumNullResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusBadRequest) {
		return PathsEnumNullResponse{}, client.enumNullHandleError(resp)
	}
	return PathsEnumNullResponse{RawResponse: resp}, nil
}
func (client *PathsClient) enumNullCreateRequest(ctx context.Context, enumPath URIColor, options *PathsEnumNullOptions) (*policy.Request, error) {
	urlPath := "/paths/string/null/{enumPath}"
	if enumPath == "" {
		return nil, errors.New("parameter enumPath cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{enumPath}", url.PathEscape(string(enumPath)))
	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 *PathsClient) enumNullHandleError(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 *PathsClient) EnumValid(ctx context.Context, enumPath URIColor, options *PathsEnumValidOptions) (PathsEnumValidResponse, error) {
	req, err := client.enumValidCreateRequest(ctx, enumPath, options)
	if err != nil {
		return PathsEnumValidResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsEnumValidResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsEnumValidResponse{}, client.enumValidHandleError(resp)
	}
	return PathsEnumValidResponse{RawResponse: resp}, nil
}
func (client *PathsClient) enumValidCreateRequest(ctx context.Context, enumPath URIColor, options *PathsEnumValidOptions) (*policy.Request, error) {
	urlPath := "/paths/enum/green%20color/{enumPath}"
	if enumPath == "" {
		return nil, errors.New("parameter enumPath cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{enumPath}", url.PathEscape(string(enumPath)))
	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 *PathsClient) enumValidHandleError(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 *PathsClient) FloatScientificNegative(ctx context.Context, options *PathsFloatScientificNegativeOptions) (PathsFloatScientificNegativeResponse, error) {
	req, err := client.floatScientificNegativeCreateRequest(ctx, options)
	if err != nil {
		return PathsFloatScientificNegativeResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsFloatScientificNegativeResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsFloatScientificNegativeResponse{}, client.floatScientificNegativeHandleError(resp)
	}
	return PathsFloatScientificNegativeResponse{RawResponse: resp}, nil
}
func (client *PathsClient) floatScientificNegativeCreateRequest(ctx context.Context, options *PathsFloatScientificNegativeOptions) (*policy.Request, error) {
	urlPath := "/paths/float/-1.034E-20/{floatPath}"
	urlPath = strings.ReplaceAll(urlPath, "{floatPath}", url.PathEscape("-1.034e-20"))
	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 *PathsClient) floatScientificNegativeHandleError(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 *PathsClient) FloatScientificPositive(ctx context.Context, options *PathsFloatScientificPositiveOptions) (PathsFloatScientificPositiveResponse, error) {
	req, err := client.floatScientificPositiveCreateRequest(ctx, options)
	if err != nil {
		return PathsFloatScientificPositiveResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsFloatScientificPositiveResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsFloatScientificPositiveResponse{}, client.floatScientificPositiveHandleError(resp)
	}
	return PathsFloatScientificPositiveResponse{RawResponse: resp}, nil
}
func (client *PathsClient) floatScientificPositiveCreateRequest(ctx context.Context, options *PathsFloatScientificPositiveOptions) (*policy.Request, error) {
	urlPath := "/paths/float/1.034E+20/{floatPath}"
	urlPath = strings.ReplaceAll(urlPath, "{floatPath}", url.PathEscape("103400000000000000000"))
	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 *PathsClient) floatScientificPositiveHandleError(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 *PathsClient) GetBooleanFalse(ctx context.Context, options *PathsGetBooleanFalseOptions) (PathsGetBooleanFalseResponse, error) {
	req, err := client.getBooleanFalseCreateRequest(ctx, options)
	if err != nil {
		return PathsGetBooleanFalseResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsGetBooleanFalseResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsGetBooleanFalseResponse{}, client.getBooleanFalseHandleError(resp)
	}
	return PathsGetBooleanFalseResponse{RawResponse: resp}, nil
}
func (client *PathsClient) getBooleanFalseCreateRequest(ctx context.Context, options *PathsGetBooleanFalseOptions) (*policy.Request, error) {
	urlPath := "/paths/bool/false/{boolPath}"
	urlPath = strings.ReplaceAll(urlPath, "{boolPath}", url.PathEscape("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 *PathsClient) getBooleanFalseHandleError(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 *PathsClient) GetBooleanTrue(ctx context.Context, options *PathsGetBooleanTrueOptions) (PathsGetBooleanTrueResponse, error) {
	req, err := client.getBooleanTrueCreateRequest(ctx, options)
	if err != nil {
		return PathsGetBooleanTrueResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsGetBooleanTrueResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsGetBooleanTrueResponse{}, client.getBooleanTrueHandleError(resp)
	}
	return PathsGetBooleanTrueResponse{RawResponse: resp}, nil
}
func (client *PathsClient) getBooleanTrueCreateRequest(ctx context.Context, options *PathsGetBooleanTrueOptions) (*policy.Request, error) {
	urlPath := "/paths/bool/true/{boolPath}"
	urlPath = strings.ReplaceAll(urlPath, "{boolPath}", url.PathEscape("true"))
	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 *PathsClient) getBooleanTrueHandleError(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 *PathsClient) GetIntNegativeOneMillion(ctx context.Context, options *PathsGetIntNegativeOneMillionOptions) (PathsGetIntNegativeOneMillionResponse, error) {
	req, err := client.getIntNegativeOneMillionCreateRequest(ctx, options)
	if err != nil {
		return PathsGetIntNegativeOneMillionResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsGetIntNegativeOneMillionResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsGetIntNegativeOneMillionResponse{}, client.getIntNegativeOneMillionHandleError(resp)
	}
	return PathsGetIntNegativeOneMillionResponse{RawResponse: resp}, nil
}
func (client *PathsClient) getIntNegativeOneMillionCreateRequest(ctx context.Context, options *PathsGetIntNegativeOneMillionOptions) (*policy.Request, error) {
	urlPath := "/paths/int/-1000000/{intPath}"
	urlPath = strings.ReplaceAll(urlPath, "{intPath}", url.PathEscape("-1000000"))
	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 *PathsClient) getIntNegativeOneMillionHandleError(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 *PathsClient) GetIntOneMillion(ctx context.Context, options *PathsGetIntOneMillionOptions) (PathsGetIntOneMillionResponse, error) {
	req, err := client.getIntOneMillionCreateRequest(ctx, options)
	if err != nil {
		return PathsGetIntOneMillionResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsGetIntOneMillionResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsGetIntOneMillionResponse{}, client.getIntOneMillionHandleError(resp)
	}
	return PathsGetIntOneMillionResponse{RawResponse: resp}, nil
}
func (client *PathsClient) getIntOneMillionCreateRequest(ctx context.Context, options *PathsGetIntOneMillionOptions) (*policy.Request, error) {
	urlPath := "/paths/int/1000000/{intPath}"
	urlPath = strings.ReplaceAll(urlPath, "{intPath}", url.PathEscape("1000000"))
	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 *PathsClient) getIntOneMillionHandleError(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 *PathsClient) GetNegativeTenBillion(ctx context.Context, options *PathsGetNegativeTenBillionOptions) (PathsGetNegativeTenBillionResponse, error) {
	req, err := client.getNegativeTenBillionCreateRequest(ctx, options)
	if err != nil {
		return PathsGetNegativeTenBillionResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PathsGetNegativeTenBillionResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PathsGetNegativeTenBillionResponse{}, client.getNegativeTenBillionHandleError(resp)
	}
	return PathsGetNegativeTenBillionResponse{RawResponse: resp}, nil
}
func (client *PathsClient) getNegativeTenBillionCreateRequest(ctx context.Context, options *PathsGetNegativeTenBillionOptions) (*policy.Request, error) {
	urlPath := "/paths/long/-10000000000/{longPath}"
	urlPath = strings.ReplaceAll(urlPath, "{longPath}", url.PathEscape("-10000000000"))
	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 *PathsClient) getNegativeTenBillionHandleError(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)
}