func (client *PagingClient) nextFragmentCreateRequest(ctx context.Context, apiVersion string, tenant string, nextLink string) (*policy.Request, error) {
	urlPath := "/paging/multiple/fragment/{tenant}/{nextLink}"
	if tenant == "" {
		return nil, errors.New("parameter tenant cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{tenant}", url.PathEscape(tenant))
	urlPath = strings.ReplaceAll(urlPath, "{nextLink}", nextLink)
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("api_version", apiVersion)
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
nextFragmentCreateRequest creates the NextFragment request.
package paginggroup
import (
	"context"
	"errors"
	armruntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm/runtime"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
	"net/url"
	"strconv"
	"strings"
)
type PagingClient struct {
	con *Connection
}
func NewPagingClient(con *Connection) *PagingClient {
	return &PagingClient{con: con}
}
func (client *PagingClient) FirstResponseEmpty(options *PagingFirstResponseEmptyOptions) *PagingFirstResponseEmptyPager {
	return &PagingFirstResponseEmptyPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.firstResponseEmptyCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingFirstResponseEmptyResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResultValue.NextLink)
		},
	}
}
func (client *PagingClient) firstResponseEmptyCreateRequest(ctx context.Context, options *PagingFirstResponseEmptyOptions) (*policy.Request, error) {
	urlPath := "/paging/firstResponseEmpty/1"
	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 *PagingClient) firstResponseEmptyHandleResponse(resp *http.Response) (PagingFirstResponseEmptyResponse, error) {
	result := PagingFirstResponseEmptyResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResultValue); err != nil {
		return PagingFirstResponseEmptyResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) firstResponseEmptyHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePages(options *PagingGetMultiplePagesOptions) *PagingGetMultiplePagesPager {
	return &PagingGetMultiplePagesPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getMultiplePagesCreateRequest(ctx context.Context, options *PagingGetMultiplePagesOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	if options != nil && options.ClientRequestID != nil {
		req.Raw().Header.Set("client-request-id", *options.ClientRequestID)
	}
	if options != nil && options.Maxresults != nil {
		req.Raw().Header.Set("maxresults", strconv.FormatInt(int64(*options.Maxresults), 10))
	}
	if options != nil && options.Timeout != nil {
		req.Raw().Header.Set("timeout", strconv.FormatInt(int64(*options.Timeout), 10))
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *PagingClient) getMultiplePagesHandleResponse(resp *http.Response) (PagingGetMultiplePagesResponse, error) {
	result := PagingGetMultiplePagesResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetMultiplePagesResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePagesFailure(options *PagingGetMultiplePagesFailureOptions) *PagingGetMultiplePagesFailurePager {
	return &PagingGetMultiplePagesFailurePager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesFailureCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesFailureResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getMultiplePagesFailureCreateRequest(ctx context.Context, options *PagingGetMultiplePagesFailureOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/failure"
	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 *PagingClient) getMultiplePagesFailureHandleResponse(resp *http.Response) (PagingGetMultiplePagesFailureResponse, error) {
	result := PagingGetMultiplePagesFailureResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetMultiplePagesFailureResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesFailureHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePagesFailureURI(options *PagingGetMultiplePagesFailureURIOptions) *PagingGetMultiplePagesFailureURIPager {
	return &PagingGetMultiplePagesFailureURIPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesFailureURICreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesFailureURIResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getMultiplePagesFailureURICreateRequest(ctx context.Context, options *PagingGetMultiplePagesFailureURIOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/failureuri"
	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 *PagingClient) getMultiplePagesFailureURIHandleResponse(resp *http.Response) (PagingGetMultiplePagesFailureURIResponse, error) {
	result := PagingGetMultiplePagesFailureURIResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetMultiplePagesFailureURIResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesFailureURIHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePagesFragmentNextLink(apiVersion string, tenant string, options *PagingGetMultiplePagesFragmentNextLinkOptions) *PagingGetMultiplePagesFragmentNextLinkPager {
	return &PagingGetMultiplePagesFragmentNextLinkPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesFragmentNextLinkCreateRequest(ctx, apiVersion, tenant, options)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesFragmentNextLinkResponse) (*policy.Request, error) {
			return client.nextFragmentCreateRequest(ctx, apiVersion, tenant, *resp.ODataProductResult.ODataNextLink)
		},
	}
}
func (client *PagingClient) getMultiplePagesFragmentNextLinkCreateRequest(ctx context.Context, apiVersion string, tenant string, options *PagingGetMultiplePagesFragmentNextLinkOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/fragment/{tenant}"
	if tenant == "" {
		return nil, errors.New("parameter tenant cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{tenant}", url.PathEscape(tenant))
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("api_version", apiVersion)
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *PagingClient) getMultiplePagesFragmentNextLinkHandleResponse(resp *http.Response) (PagingGetMultiplePagesFragmentNextLinkResponse, error) {
	result := PagingGetMultiplePagesFragmentNextLinkResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ODataProductResult); err != nil {
		return PagingGetMultiplePagesFragmentNextLinkResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesFragmentNextLinkHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePagesFragmentWithGroupingNextLink(customParameterGroup CustomParameterGroup) *PagingGetMultiplePagesFragmentWithGroupingNextLinkPager {
	return &PagingGetMultiplePagesFragmentWithGroupingNextLinkPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesFragmentWithGroupingNextLinkCreateRequest(ctx, customParameterGroup)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesFragmentWithGroupingNextLinkResponse) (*policy.Request, error) {
			return client.nextFragmentWithGroupingCreateRequest(ctx, *resp.ODataProductResult.ODataNextLink, customParameterGroup)
		},
	}
}
func (client *PagingClient) getMultiplePagesFragmentWithGroupingNextLinkCreateRequest(ctx context.Context, customParameterGroup CustomParameterGroup) (*policy.Request, error) {
	urlPath := "/paging/multiple/fragmentwithgrouping/{tenant}"
	if customParameterGroup.Tenant == "" {
		return nil, errors.New("parameter customParameterGroup.Tenant cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{tenant}", url.PathEscape(customParameterGroup.Tenant))
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("api_version", customParameterGroup.APIVersion)
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *PagingClient) getMultiplePagesFragmentWithGroupingNextLinkHandleResponse(resp *http.Response) (PagingGetMultiplePagesFragmentWithGroupingNextLinkResponse, error) {
	result := PagingGetMultiplePagesFragmentWithGroupingNextLinkResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ODataProductResult); err != nil {
		return PagingGetMultiplePagesFragmentWithGroupingNextLinkResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesFragmentWithGroupingNextLinkHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) BeginGetMultiplePagesLRO(ctx context.Context, options *PagingBeginGetMultiplePagesLROOptions) (PagingGetMultiplePagesLROPollerResponse, error) {
	resp, err := client.getMultiplePagesLRO(ctx, options)
	if err != nil {
		return PagingGetMultiplePagesLROPollerResponse{}, err
	}
	result := PagingGetMultiplePagesLROPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("PagingClient.GetMultiplePagesLRO", "", resp, client.con.Pipeline(), client.getMultiplePagesLROHandleError)
	if err != nil {
		return PagingGetMultiplePagesLROPollerResponse{}, err
	}
	result.Poller = &PagingGetMultiplePagesLROPoller{
		pt:     pt,
		client: client,
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesLRO(ctx context.Context, options *PagingBeginGetMultiplePagesLROOptions) (*http.Response, error) {
	req, err := client.getMultiplePagesLROCreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusAccepted) {
		return nil, client.getMultiplePagesLROHandleError(resp)
	}
	return resp, nil
}
func (client *PagingClient) getMultiplePagesLROCreateRequest(ctx context.Context, options *PagingBeginGetMultiplePagesLROOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/lro"
	req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	if options != nil && options.ClientRequestID != nil {
		req.Raw().Header.Set("client-request-id", *options.ClientRequestID)
	}
	if options != nil && options.Maxresults != nil {
		req.Raw().Header.Set("maxresults", strconv.FormatInt(int64(*options.Maxresults), 10))
	}
	if options != nil && options.Timeout != nil {
		req.Raw().Header.Set("timeout", strconv.FormatInt(int64(*options.Timeout), 10))
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *PagingClient) getMultiplePagesLROHandleResponse(resp *http.Response) (PagingGetMultiplePagesLROResponse, error) {
	result := PagingGetMultiplePagesLROResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetMultiplePagesLROResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesLROHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePagesRetryFirst(options *PagingGetMultiplePagesRetryFirstOptions) *PagingGetMultiplePagesRetryFirstPager {
	return &PagingGetMultiplePagesRetryFirstPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesRetryFirstCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesRetryFirstResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getMultiplePagesRetryFirstCreateRequest(ctx context.Context, options *PagingGetMultiplePagesRetryFirstOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/retryfirst"
	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 *PagingClient) getMultiplePagesRetryFirstHandleResponse(resp *http.Response) (PagingGetMultiplePagesRetryFirstResponse, error) {
	result := PagingGetMultiplePagesRetryFirstResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetMultiplePagesRetryFirstResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesRetryFirstHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePagesRetrySecond(options *PagingGetMultiplePagesRetrySecondOptions) *PagingGetMultiplePagesRetrySecondPager {
	return &PagingGetMultiplePagesRetrySecondPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesRetrySecondCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesRetrySecondResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getMultiplePagesRetrySecondCreateRequest(ctx context.Context, options *PagingGetMultiplePagesRetrySecondOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/retrysecond"
	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 *PagingClient) getMultiplePagesRetrySecondHandleResponse(resp *http.Response) (PagingGetMultiplePagesRetrySecondResponse, error) {
	result := PagingGetMultiplePagesRetrySecondResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetMultiplePagesRetrySecondResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesRetrySecondHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetMultiplePagesWithOffset(pagingGetMultiplePagesWithOffsetOptions PagingGetMultiplePagesWithOffsetOptions) *PagingGetMultiplePagesWithOffsetPager {
	return &PagingGetMultiplePagesWithOffsetPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getMultiplePagesWithOffsetCreateRequest(ctx, pagingGetMultiplePagesWithOffsetOptions)
		},
		advancer: func(ctx context.Context, resp PagingGetMultiplePagesWithOffsetResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getMultiplePagesWithOffsetCreateRequest(ctx context.Context, pagingGetMultiplePagesWithOffsetOptions PagingGetMultiplePagesWithOffsetOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/withpath/{offset}"
	urlPath = strings.ReplaceAll(urlPath, "{offset}", url.PathEscape(strconv.FormatInt(int64(pagingGetMultiplePagesWithOffsetOptions.Offset), 10)))
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	if pagingGetMultiplePagesWithOffsetOptions.ClientRequestID != nil {
		req.Raw().Header.Set("client-request-id", *pagingGetMultiplePagesWithOffsetOptions.ClientRequestID)
	}
	if pagingGetMultiplePagesWithOffsetOptions.Maxresults != nil {
		req.Raw().Header.Set("maxresults", strconv.FormatInt(int64(*pagingGetMultiplePagesWithOffsetOptions.Maxresults), 10))
	}
	if pagingGetMultiplePagesWithOffsetOptions.Timeout != nil {
		req.Raw().Header.Set("timeout", strconv.FormatInt(int64(*pagingGetMultiplePagesWithOffsetOptions.Timeout), 10))
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *PagingClient) getMultiplePagesWithOffsetHandleResponse(resp *http.Response) (PagingGetMultiplePagesWithOffsetResponse, error) {
	result := PagingGetMultiplePagesWithOffsetResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetMultiplePagesWithOffsetResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getMultiplePagesWithOffsetHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetNoItemNamePages(options *PagingGetNoItemNamePagesOptions) *PagingGetNoItemNamePagesPager {
	return &PagingGetNoItemNamePagesPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getNoItemNamePagesCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetNoItemNamePagesResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResultValue.NextLink)
		},
	}
}
func (client *PagingClient) getNoItemNamePagesCreateRequest(ctx context.Context, options *PagingGetNoItemNamePagesOptions) (*policy.Request, error) {
	urlPath := "/paging/noitemname"
	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 *PagingClient) getNoItemNamePagesHandleResponse(resp *http.Response) (PagingGetNoItemNamePagesResponse, error) {
	result := PagingGetNoItemNamePagesResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResultValue); err != nil {
		return PagingGetNoItemNamePagesResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getNoItemNamePagesHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetNullNextLinkNamePages(ctx context.Context, options *PagingGetNullNextLinkNamePagesOptions) (PagingGetNullNextLinkNamePagesResponse, error) {
	req, err := client.getNullNextLinkNamePagesCreateRequest(ctx, options)
	if err != nil {
		return PagingGetNullNextLinkNamePagesResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return PagingGetNullNextLinkNamePagesResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return PagingGetNullNextLinkNamePagesResponse{}, client.getNullNextLinkNamePagesHandleError(resp)
	}
	return client.getNullNextLinkNamePagesHandleResponse(resp)
}
func (client *PagingClient) getNullNextLinkNamePagesCreateRequest(ctx context.Context, options *PagingGetNullNextLinkNamePagesOptions) (*policy.Request, error) {
	urlPath := "/paging/nullnextlink"
	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 *PagingClient) getNullNextLinkNamePagesHandleResponse(resp *http.Response) (PagingGetNullNextLinkNamePagesResponse, error) {
	result := PagingGetNullNextLinkNamePagesResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetNullNextLinkNamePagesResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getNullNextLinkNamePagesHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetODataMultiplePages(options *PagingGetODataMultiplePagesOptions) *PagingGetODataMultiplePagesPager {
	return &PagingGetODataMultiplePagesPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getODataMultiplePagesCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetODataMultiplePagesResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ODataProductResult.ODataNextLink)
		},
	}
}
func (client *PagingClient) getODataMultiplePagesCreateRequest(ctx context.Context, options *PagingGetODataMultiplePagesOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/odata"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	if options != nil && options.ClientRequestID != nil {
		req.Raw().Header.Set("client-request-id", *options.ClientRequestID)
	}
	if options != nil && options.Maxresults != nil {
		req.Raw().Header.Set("maxresults", strconv.FormatInt(int64(*options.Maxresults), 10))
	}
	if options != nil && options.Timeout != nil {
		req.Raw().Header.Set("timeout", strconv.FormatInt(int64(*options.Timeout), 10))
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *PagingClient) getODataMultiplePagesHandleResponse(resp *http.Response) (PagingGetODataMultiplePagesResponse, error) {
	result := PagingGetODataMultiplePagesResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ODataProductResult); err != nil {
		return PagingGetODataMultiplePagesResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getODataMultiplePagesHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetPagingModelWithItemNameWithXMSClientName(options *PagingGetPagingModelWithItemNameWithXMSClientNameOptions) *PagingGetPagingModelWithItemNameWithXMSClientNamePager {
	return &PagingGetPagingModelWithItemNameWithXMSClientNamePager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getPagingModelWithItemNameWithXMSClientNameCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetPagingModelWithItemNameWithXMSClientNameResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResultValueWithXMSClientName.NextLink)
		},
	}
}
func (client *PagingClient) getPagingModelWithItemNameWithXMSClientNameCreateRequest(ctx context.Context, options *PagingGetPagingModelWithItemNameWithXMSClientNameOptions) (*policy.Request, error) {
	urlPath := "/paging/itemNameWithXMSClientName"
	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 *PagingClient) getPagingModelWithItemNameWithXMSClientNameHandleResponse(resp *http.Response) (PagingGetPagingModelWithItemNameWithXMSClientNameResponse, error) {
	result := PagingGetPagingModelWithItemNameWithXMSClientNameResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResultValueWithXMSClientName); err != nil {
		return PagingGetPagingModelWithItemNameWithXMSClientNameResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getPagingModelWithItemNameWithXMSClientNameHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetSinglePages(options *PagingGetSinglePagesOptions) *PagingGetSinglePagesPager {
	return &PagingGetSinglePagesPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getSinglePagesCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetSinglePagesResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getSinglePagesCreateRequest(ctx context.Context, options *PagingGetSinglePagesOptions) (*policy.Request, error) {
	urlPath := "/paging/single"
	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 *PagingClient) getSinglePagesHandleResponse(resp *http.Response) (PagingGetSinglePagesResponse, error) {
	result := PagingGetSinglePagesResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetSinglePagesResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getSinglePagesHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetSinglePagesFailure(options *PagingGetSinglePagesFailureOptions) *PagingGetSinglePagesFailurePager {
	return &PagingGetSinglePagesFailurePager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getSinglePagesFailureCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp PagingGetSinglePagesFailureResponse) (*policy.Request, error) {
			return runtime.NewRequest(ctx, http.MethodGet, *resp.ProductResult.NextLink)
		},
	}
}
func (client *PagingClient) getSinglePagesFailureCreateRequest(ctx context.Context, options *PagingGetSinglePagesFailureOptions) (*policy.Request, error) {
	urlPath := "/paging/single/failure"
	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 *PagingClient) getSinglePagesFailureHandleResponse(resp *http.Response) (PagingGetSinglePagesFailureResponse, error) {
	result := PagingGetSinglePagesFailureResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetSinglePagesFailureResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getSinglePagesFailureHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *PagingClient) GetWithQueryParams(requiredQueryParameter int32, options *PagingGetWithQueryParamsOptions) *PagingGetWithQueryParamsPager {
	return &PagingGetWithQueryParamsPager{
		client: client,
		requester: func(ctx context.Context) (*policy.Request, error) {
			return client.getWithQueryParamsCreateRequest(ctx, requiredQueryParameter, options)
		},
		advancer: func(ctx context.Context, resp PagingGetWithQueryParamsResponse) (*policy.Request, error) {
			return client.nextOperationWithQueryParamsCreateRequest(ctx)
		},
	}
}
func (client *PagingClient) getWithQueryParamsCreateRequest(ctx context.Context, requiredQueryParameter int32, options *PagingGetWithQueryParamsOptions) (*policy.Request, error) {
	urlPath := "/paging/multiple/getWithQueryParams"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("requiredQueryParameter", strconv.FormatInt(int64(requiredQueryParameter), 10))
	reqQP.Set("queryConstant", "true")
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *PagingClient) getWithQueryParamsHandleResponse(resp *http.Response) (PagingGetWithQueryParamsResponse, error) {
	result := PagingGetWithQueryParamsResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.ProductResult); err != nil {
		return PagingGetWithQueryParamsResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *PagingClient) getWithQueryParamsHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}