xref: /dports/www/grafana8/grafana-8.3.6/vendor/github.com/Azure/azure-sdk-for-go/sdk/network/armnetwork/zz_generated_pagers.go

// +build go1.13

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

package armnetwork

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"reflect"
)

// ApplicationGatewayAvailableSSLPredefinedPoliciesPager provides iteration over ApplicationGatewayAvailableSSLPredefinedPolicies pages.
type ApplicationGatewayAvailableSSLPredefinedPoliciesPager interface {
	azcore.Pager

	// PageResponse returns the current ApplicationGatewayAvailableSSLPredefinedPoliciesResponse.
	PageResponse() ApplicationGatewayAvailableSSLPredefinedPoliciesResponse
}

type applicationGatewayAvailableSSLPredefinedPoliciesCreateRequest func(context.Context) (*azcore.Request, error)

type applicationGatewayAvailableSSLPredefinedPoliciesHandleError func(*azcore.Response) error

type applicationGatewayAvailableSSLPredefinedPoliciesHandleResponse func(*azcore.Response) (ApplicationGatewayAvailableSSLPredefinedPoliciesResponse, error)

type applicationGatewayAvailableSSLPredefinedPoliciesAdvancePage func(context.Context, ApplicationGatewayAvailableSSLPredefinedPoliciesResponse) (*azcore.Request, error)

type applicationGatewayAvailableSSLPredefinedPoliciesPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester applicationGatewayAvailableSSLPredefinedPoliciesCreateRequest
	// callback for handling response errors
	errorer applicationGatewayAvailableSSLPredefinedPoliciesHandleError
	// callback for handling the HTTP response
	responder applicationGatewayAvailableSSLPredefinedPoliciesHandleResponse
	// callback for advancing to the next page
	advancer applicationGatewayAvailableSSLPredefinedPoliciesAdvancePage
	// contains the current response
	current ApplicationGatewayAvailableSSLPredefinedPoliciesResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *applicationGatewayAvailableSSLPredefinedPoliciesPager) Err() error {
	return p.err
}

func (p *applicationGatewayAvailableSSLPredefinedPoliciesPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ApplicationGatewayAvailableSSLPredefinedPolicies.NextLink == nil || len(*p.current.ApplicationGatewayAvailableSSLPredefinedPolicies.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *applicationGatewayAvailableSSLPredefinedPoliciesPager) PageResponse() ApplicationGatewayAvailableSSLPredefinedPoliciesResponse {
	return p.current
}

// ApplicationGatewayListResultPager provides iteration over ApplicationGatewayListResult pages.
type ApplicationGatewayListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ApplicationGatewayListResultResponse.
	PageResponse() ApplicationGatewayListResultResponse
}

type applicationGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error)

type applicationGatewayListResultHandleError func(*azcore.Response) error

type applicationGatewayListResultHandleResponse func(*azcore.Response) (ApplicationGatewayListResultResponse, error)

type applicationGatewayListResultAdvancePage func(context.Context, ApplicationGatewayListResultResponse) (*azcore.Request, error)

type applicationGatewayListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester applicationGatewayListResultCreateRequest
	// callback for handling response errors
	errorer applicationGatewayListResultHandleError
	// callback for handling the HTTP response
	responder applicationGatewayListResultHandleResponse
	// callback for advancing to the next page
	advancer applicationGatewayListResultAdvancePage
	// contains the current response
	current ApplicationGatewayListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *applicationGatewayListResultPager) Err() error {
	return p.err
}

func (p *applicationGatewayListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ApplicationGatewayListResult.NextLink == nil || len(*p.current.ApplicationGatewayListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *applicationGatewayListResultPager) PageResponse() ApplicationGatewayListResultResponse {
	return p.current
}

// ApplicationGatewayPrivateEndpointConnectionListResultPager provides iteration over ApplicationGatewayPrivateEndpointConnectionListResult pages.
type ApplicationGatewayPrivateEndpointConnectionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ApplicationGatewayPrivateEndpointConnectionListResultResponse.
	PageResponse() ApplicationGatewayPrivateEndpointConnectionListResultResponse
}

type applicationGatewayPrivateEndpointConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type applicationGatewayPrivateEndpointConnectionListResultHandleError func(*azcore.Response) error

type applicationGatewayPrivateEndpointConnectionListResultHandleResponse func(*azcore.Response) (ApplicationGatewayPrivateEndpointConnectionListResultResponse, error)

type applicationGatewayPrivateEndpointConnectionListResultAdvancePage func(context.Context, ApplicationGatewayPrivateEndpointConnectionListResultResponse) (*azcore.Request, error)

type applicationGatewayPrivateEndpointConnectionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester applicationGatewayPrivateEndpointConnectionListResultCreateRequest
	// callback for handling response errors
	errorer applicationGatewayPrivateEndpointConnectionListResultHandleError
	// callback for handling the HTTP response
	responder applicationGatewayPrivateEndpointConnectionListResultHandleResponse
	// callback for advancing to the next page
	advancer applicationGatewayPrivateEndpointConnectionListResultAdvancePage
	// contains the current response
	current ApplicationGatewayPrivateEndpointConnectionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *applicationGatewayPrivateEndpointConnectionListResultPager) Err() error {
	return p.err
}

func (p *applicationGatewayPrivateEndpointConnectionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ApplicationGatewayPrivateEndpointConnectionListResult.NextLink == nil || len(*p.current.ApplicationGatewayPrivateEndpointConnectionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *applicationGatewayPrivateEndpointConnectionListResultPager) PageResponse() ApplicationGatewayPrivateEndpointConnectionListResultResponse {
	return p.current
}

// ApplicationGatewayPrivateLinkResourceListResultPager provides iteration over ApplicationGatewayPrivateLinkResourceListResult pages.
type ApplicationGatewayPrivateLinkResourceListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ApplicationGatewayPrivateLinkResourceListResultResponse.
	PageResponse() ApplicationGatewayPrivateLinkResourceListResultResponse
}

type applicationGatewayPrivateLinkResourceListResultCreateRequest func(context.Context) (*azcore.Request, error)

type applicationGatewayPrivateLinkResourceListResultHandleError func(*azcore.Response) error

type applicationGatewayPrivateLinkResourceListResultHandleResponse func(*azcore.Response) (ApplicationGatewayPrivateLinkResourceListResultResponse, error)

type applicationGatewayPrivateLinkResourceListResultAdvancePage func(context.Context, ApplicationGatewayPrivateLinkResourceListResultResponse) (*azcore.Request, error)

type applicationGatewayPrivateLinkResourceListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester applicationGatewayPrivateLinkResourceListResultCreateRequest
	// callback for handling response errors
	errorer applicationGatewayPrivateLinkResourceListResultHandleError
	// callback for handling the HTTP response
	responder applicationGatewayPrivateLinkResourceListResultHandleResponse
	// callback for advancing to the next page
	advancer applicationGatewayPrivateLinkResourceListResultAdvancePage
	// contains the current response
	current ApplicationGatewayPrivateLinkResourceListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *applicationGatewayPrivateLinkResourceListResultPager) Err() error {
	return p.err
}

func (p *applicationGatewayPrivateLinkResourceListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ApplicationGatewayPrivateLinkResourceListResult.NextLink == nil || len(*p.current.ApplicationGatewayPrivateLinkResourceListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *applicationGatewayPrivateLinkResourceListResultPager) PageResponse() ApplicationGatewayPrivateLinkResourceListResultResponse {
	return p.current
}

// ApplicationSecurityGroupListResultPager provides iteration over ApplicationSecurityGroupListResult pages.
type ApplicationSecurityGroupListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ApplicationSecurityGroupListResultResponse.
	PageResponse() ApplicationSecurityGroupListResultResponse
}

type applicationSecurityGroupListResultCreateRequest func(context.Context) (*azcore.Request, error)

type applicationSecurityGroupListResultHandleError func(*azcore.Response) error

type applicationSecurityGroupListResultHandleResponse func(*azcore.Response) (ApplicationSecurityGroupListResultResponse, error)

type applicationSecurityGroupListResultAdvancePage func(context.Context, ApplicationSecurityGroupListResultResponse) (*azcore.Request, error)

type applicationSecurityGroupListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester applicationSecurityGroupListResultCreateRequest
	// callback for handling response errors
	errorer applicationSecurityGroupListResultHandleError
	// callback for handling the HTTP response
	responder applicationSecurityGroupListResultHandleResponse
	// callback for advancing to the next page
	advancer applicationSecurityGroupListResultAdvancePage
	// contains the current response
	current ApplicationSecurityGroupListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *applicationSecurityGroupListResultPager) Err() error {
	return p.err
}

func (p *applicationSecurityGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ApplicationSecurityGroupListResult.NextLink == nil || len(*p.current.ApplicationSecurityGroupListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *applicationSecurityGroupListResultPager) PageResponse() ApplicationSecurityGroupListResultResponse {
	return p.current
}

// AuthorizationListResultPager provides iteration over AuthorizationListResult pages.
type AuthorizationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current AuthorizationListResultResponse.
	PageResponse() AuthorizationListResultResponse
}

type authorizationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type authorizationListResultHandleError func(*azcore.Response) error

type authorizationListResultHandleResponse func(*azcore.Response) (AuthorizationListResultResponse, error)

type authorizationListResultAdvancePage func(context.Context, AuthorizationListResultResponse) (*azcore.Request, error)

type authorizationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester authorizationListResultCreateRequest
	// callback for handling response errors
	errorer authorizationListResultHandleError
	// callback for handling the HTTP response
	responder authorizationListResultHandleResponse
	// callback for advancing to the next page
	advancer authorizationListResultAdvancePage
	// contains the current response
	current AuthorizationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *authorizationListResultPager) Err() error {
	return p.err
}

func (p *authorizationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AuthorizationListResult.NextLink == nil || len(*p.current.AuthorizationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *authorizationListResultPager) PageResponse() AuthorizationListResultResponse {
	return p.current
}

// AutoApprovedPrivateLinkServicesResultPager provides iteration over AutoApprovedPrivateLinkServicesResult pages.
type AutoApprovedPrivateLinkServicesResultPager interface {
	azcore.Pager

	// PageResponse returns the current AutoApprovedPrivateLinkServicesResultResponse.
	PageResponse() AutoApprovedPrivateLinkServicesResultResponse
}

type autoApprovedPrivateLinkServicesResultCreateRequest func(context.Context) (*azcore.Request, error)

type autoApprovedPrivateLinkServicesResultHandleError func(*azcore.Response) error

type autoApprovedPrivateLinkServicesResultHandleResponse func(*azcore.Response) (AutoApprovedPrivateLinkServicesResultResponse, error)

type autoApprovedPrivateLinkServicesResultAdvancePage func(context.Context, AutoApprovedPrivateLinkServicesResultResponse) (*azcore.Request, error)

type autoApprovedPrivateLinkServicesResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester autoApprovedPrivateLinkServicesResultCreateRequest
	// callback for handling response errors
	errorer autoApprovedPrivateLinkServicesResultHandleError
	// callback for handling the HTTP response
	responder autoApprovedPrivateLinkServicesResultHandleResponse
	// callback for advancing to the next page
	advancer autoApprovedPrivateLinkServicesResultAdvancePage
	// contains the current response
	current AutoApprovedPrivateLinkServicesResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *autoApprovedPrivateLinkServicesResultPager) Err() error {
	return p.err
}

func (p *autoApprovedPrivateLinkServicesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AutoApprovedPrivateLinkServicesResult.NextLink == nil || len(*p.current.AutoApprovedPrivateLinkServicesResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *autoApprovedPrivateLinkServicesResultPager) PageResponse() AutoApprovedPrivateLinkServicesResultResponse {
	return p.current
}

// AvailableDelegationsResultPager provides iteration over AvailableDelegationsResult pages.
type AvailableDelegationsResultPager interface {
	azcore.Pager

	// PageResponse returns the current AvailableDelegationsResultResponse.
	PageResponse() AvailableDelegationsResultResponse
}

type availableDelegationsResultCreateRequest func(context.Context) (*azcore.Request, error)

type availableDelegationsResultHandleError func(*azcore.Response) error

type availableDelegationsResultHandleResponse func(*azcore.Response) (AvailableDelegationsResultResponse, error)

type availableDelegationsResultAdvancePage func(context.Context, AvailableDelegationsResultResponse) (*azcore.Request, error)

type availableDelegationsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester availableDelegationsResultCreateRequest
	// callback for handling response errors
	errorer availableDelegationsResultHandleError
	// callback for handling the HTTP response
	responder availableDelegationsResultHandleResponse
	// callback for advancing to the next page
	advancer availableDelegationsResultAdvancePage
	// contains the current response
	current AvailableDelegationsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *availableDelegationsResultPager) Err() error {
	return p.err
}

func (p *availableDelegationsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AvailableDelegationsResult.NextLink == nil || len(*p.current.AvailableDelegationsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *availableDelegationsResultPager) PageResponse() AvailableDelegationsResultResponse {
	return p.current
}

// AvailablePrivateEndpointTypesResultPager provides iteration over AvailablePrivateEndpointTypesResult pages.
type AvailablePrivateEndpointTypesResultPager interface {
	azcore.Pager

	// PageResponse returns the current AvailablePrivateEndpointTypesResultResponse.
	PageResponse() AvailablePrivateEndpointTypesResultResponse
}

type availablePrivateEndpointTypesResultCreateRequest func(context.Context) (*azcore.Request, error)

type availablePrivateEndpointTypesResultHandleError func(*azcore.Response) error

type availablePrivateEndpointTypesResultHandleResponse func(*azcore.Response) (AvailablePrivateEndpointTypesResultResponse, error)

type availablePrivateEndpointTypesResultAdvancePage func(context.Context, AvailablePrivateEndpointTypesResultResponse) (*azcore.Request, error)

type availablePrivateEndpointTypesResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester availablePrivateEndpointTypesResultCreateRequest
	// callback for handling response errors
	errorer availablePrivateEndpointTypesResultHandleError
	// callback for handling the HTTP response
	responder availablePrivateEndpointTypesResultHandleResponse
	// callback for advancing to the next page
	advancer availablePrivateEndpointTypesResultAdvancePage
	// contains the current response
	current AvailablePrivateEndpointTypesResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *availablePrivateEndpointTypesResultPager) Err() error {
	return p.err
}

func (p *availablePrivateEndpointTypesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AvailablePrivateEndpointTypesResult.NextLink == nil || len(*p.current.AvailablePrivateEndpointTypesResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *availablePrivateEndpointTypesResultPager) PageResponse() AvailablePrivateEndpointTypesResultResponse {
	return p.current
}

// AvailableServiceAliasesResultPager provides iteration over AvailableServiceAliasesResult pages.
type AvailableServiceAliasesResultPager interface {
	azcore.Pager

	// PageResponse returns the current AvailableServiceAliasesResultResponse.
	PageResponse() AvailableServiceAliasesResultResponse
}

type availableServiceAliasesResultCreateRequest func(context.Context) (*azcore.Request, error)

type availableServiceAliasesResultHandleError func(*azcore.Response) error

type availableServiceAliasesResultHandleResponse func(*azcore.Response) (AvailableServiceAliasesResultResponse, error)

type availableServiceAliasesResultAdvancePage func(context.Context, AvailableServiceAliasesResultResponse) (*azcore.Request, error)

type availableServiceAliasesResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester availableServiceAliasesResultCreateRequest
	// callback for handling response errors
	errorer availableServiceAliasesResultHandleError
	// callback for handling the HTTP response
	responder availableServiceAliasesResultHandleResponse
	// callback for advancing to the next page
	advancer availableServiceAliasesResultAdvancePage
	// contains the current response
	current AvailableServiceAliasesResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *availableServiceAliasesResultPager) Err() error {
	return p.err
}

func (p *availableServiceAliasesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AvailableServiceAliasesResult.NextLink == nil || len(*p.current.AvailableServiceAliasesResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *availableServiceAliasesResultPager) PageResponse() AvailableServiceAliasesResultResponse {
	return p.current
}

// AzureFirewallFqdnTagListResultPager provides iteration over AzureFirewallFqdnTagListResult pages.
type AzureFirewallFqdnTagListResultPager interface {
	azcore.Pager

	// PageResponse returns the current AzureFirewallFqdnTagListResultResponse.
	PageResponse() AzureFirewallFqdnTagListResultResponse
}

type azureFirewallFqdnTagListResultCreateRequest func(context.Context) (*azcore.Request, error)

type azureFirewallFqdnTagListResultHandleError func(*azcore.Response) error

type azureFirewallFqdnTagListResultHandleResponse func(*azcore.Response) (AzureFirewallFqdnTagListResultResponse, error)

type azureFirewallFqdnTagListResultAdvancePage func(context.Context, AzureFirewallFqdnTagListResultResponse) (*azcore.Request, error)

type azureFirewallFqdnTagListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester azureFirewallFqdnTagListResultCreateRequest
	// callback for handling response errors
	errorer azureFirewallFqdnTagListResultHandleError
	// callback for handling the HTTP response
	responder azureFirewallFqdnTagListResultHandleResponse
	// callback for advancing to the next page
	advancer azureFirewallFqdnTagListResultAdvancePage
	// contains the current response
	current AzureFirewallFqdnTagListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *azureFirewallFqdnTagListResultPager) Err() error {
	return p.err
}

func (p *azureFirewallFqdnTagListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AzureFirewallFqdnTagListResult.NextLink == nil || len(*p.current.AzureFirewallFqdnTagListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *azureFirewallFqdnTagListResultPager) PageResponse() AzureFirewallFqdnTagListResultResponse {
	return p.current
}

// AzureFirewallListResultPager provides iteration over AzureFirewallListResult pages.
type AzureFirewallListResultPager interface {
	azcore.Pager

	// PageResponse returns the current AzureFirewallListResultResponse.
	PageResponse() AzureFirewallListResultResponse
}

type azureFirewallListResultCreateRequest func(context.Context) (*azcore.Request, error)

type azureFirewallListResultHandleError func(*azcore.Response) error

type azureFirewallListResultHandleResponse func(*azcore.Response) (AzureFirewallListResultResponse, error)

type azureFirewallListResultAdvancePage func(context.Context, AzureFirewallListResultResponse) (*azcore.Request, error)

type azureFirewallListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester azureFirewallListResultCreateRequest
	// callback for handling response errors
	errorer azureFirewallListResultHandleError
	// callback for handling the HTTP response
	responder azureFirewallListResultHandleResponse
	// callback for advancing to the next page
	advancer azureFirewallListResultAdvancePage
	// contains the current response
	current AzureFirewallListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *azureFirewallListResultPager) Err() error {
	return p.err
}

func (p *azureFirewallListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AzureFirewallListResult.NextLink == nil || len(*p.current.AzureFirewallListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *azureFirewallListResultPager) PageResponse() AzureFirewallListResultResponse {
	return p.current
}

// AzureWebCategoryListResultPager provides iteration over AzureWebCategoryListResult pages.
type AzureWebCategoryListResultPager interface {
	azcore.Pager

	// PageResponse returns the current AzureWebCategoryListResultResponse.
	PageResponse() AzureWebCategoryListResultResponse
}

type azureWebCategoryListResultCreateRequest func(context.Context) (*azcore.Request, error)

type azureWebCategoryListResultHandleError func(*azcore.Response) error

type azureWebCategoryListResultHandleResponse func(*azcore.Response) (AzureWebCategoryListResultResponse, error)

type azureWebCategoryListResultAdvancePage func(context.Context, AzureWebCategoryListResultResponse) (*azcore.Request, error)

type azureWebCategoryListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester azureWebCategoryListResultCreateRequest
	// callback for handling response errors
	errorer azureWebCategoryListResultHandleError
	// callback for handling the HTTP response
	responder azureWebCategoryListResultHandleResponse
	// callback for advancing to the next page
	advancer azureWebCategoryListResultAdvancePage
	// contains the current response
	current AzureWebCategoryListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *azureWebCategoryListResultPager) Err() error {
	return p.err
}

func (p *azureWebCategoryListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AzureWebCategoryListResult.NextLink == nil || len(*p.current.AzureWebCategoryListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *azureWebCategoryListResultPager) PageResponse() AzureWebCategoryListResultResponse {
	return p.current
}

// BastionActiveSessionListResultPager provides iteration over BastionActiveSessionListResult pages.
type BastionActiveSessionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current BastionActiveSessionListResultResponse.
	PageResponse() BastionActiveSessionListResultResponse
}

type bastionActiveSessionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type bastionActiveSessionListResultHandleError func(*azcore.Response) error

type bastionActiveSessionListResultHandleResponse func(*azcore.Response) (BastionActiveSessionListResultResponse, error)

type bastionActiveSessionListResultAdvancePage func(context.Context, BastionActiveSessionListResultResponse) (*azcore.Request, error)

type bastionActiveSessionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester bastionActiveSessionListResultCreateRequest
	// callback for handling response errors
	errorer bastionActiveSessionListResultHandleError
	// callback for handling the HTTP response
	responder bastionActiveSessionListResultHandleResponse
	// callback for advancing to the next page
	advancer bastionActiveSessionListResultAdvancePage
	// contains the current response
	current BastionActiveSessionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
	// previous response from the endpoint (LRO case)
	resp *azcore.Response
}

func (p *bastionActiveSessionListResultPager) Err() error {
	return p.err
}

func (p *bastionActiveSessionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.BastionActiveSessionListResult.NextLink == nil || len(*p.current.BastionActiveSessionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else if p.resp == nil {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp := p.resp
	if resp == nil {
		resp, err = p.pipeline.Do(req)
	} else {
		p.resp = nil
	}
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *bastionActiveSessionListResultPager) PageResponse() BastionActiveSessionListResultResponse {
	return p.current
}

// BastionHostListResultPager provides iteration over BastionHostListResult pages.
type BastionHostListResultPager interface {
	azcore.Pager

	// PageResponse returns the current BastionHostListResultResponse.
	PageResponse() BastionHostListResultResponse
}

type bastionHostListResultCreateRequest func(context.Context) (*azcore.Request, error)

type bastionHostListResultHandleError func(*azcore.Response) error

type bastionHostListResultHandleResponse func(*azcore.Response) (BastionHostListResultResponse, error)

type bastionHostListResultAdvancePage func(context.Context, BastionHostListResultResponse) (*azcore.Request, error)

type bastionHostListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester bastionHostListResultCreateRequest
	// callback for handling response errors
	errorer bastionHostListResultHandleError
	// callback for handling the HTTP response
	responder bastionHostListResultHandleResponse
	// callback for advancing to the next page
	advancer bastionHostListResultAdvancePage
	// contains the current response
	current BastionHostListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *bastionHostListResultPager) Err() error {
	return p.err
}

func (p *bastionHostListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.BastionHostListResult.NextLink == nil || len(*p.current.BastionHostListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *bastionHostListResultPager) PageResponse() BastionHostListResultResponse {
	return p.current
}

// BastionSessionDeleteResultPager provides iteration over BastionSessionDeleteResult pages.
type BastionSessionDeleteResultPager interface {
	azcore.Pager

	// PageResponse returns the current BastionSessionDeleteResultResponse.
	PageResponse() BastionSessionDeleteResultResponse
}

type bastionSessionDeleteResultCreateRequest func(context.Context) (*azcore.Request, error)

type bastionSessionDeleteResultHandleError func(*azcore.Response) error

type bastionSessionDeleteResultHandleResponse func(*azcore.Response) (BastionSessionDeleteResultResponse, error)

type bastionSessionDeleteResultAdvancePage func(context.Context, BastionSessionDeleteResultResponse) (*azcore.Request, error)

type bastionSessionDeleteResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester bastionSessionDeleteResultCreateRequest
	// callback for handling response errors
	errorer bastionSessionDeleteResultHandleError
	// callback for handling the HTTP response
	responder bastionSessionDeleteResultHandleResponse
	// callback for advancing to the next page
	advancer bastionSessionDeleteResultAdvancePage
	// contains the current response
	current BastionSessionDeleteResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *bastionSessionDeleteResultPager) Err() error {
	return p.err
}

func (p *bastionSessionDeleteResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.BastionSessionDeleteResult.NextLink == nil || len(*p.current.BastionSessionDeleteResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *bastionSessionDeleteResultPager) PageResponse() BastionSessionDeleteResultResponse {
	return p.current
}

// BastionShareableLinkListResultPager provides iteration over BastionShareableLinkListResult pages.
type BastionShareableLinkListResultPager interface {
	azcore.Pager

	// PageResponse returns the current BastionShareableLinkListResultResponse.
	PageResponse() BastionShareableLinkListResultResponse
}

type bastionShareableLinkListResultCreateRequest func(context.Context) (*azcore.Request, error)

type bastionShareableLinkListResultHandleError func(*azcore.Response) error

type bastionShareableLinkListResultHandleResponse func(*azcore.Response) (BastionShareableLinkListResultResponse, error)

type bastionShareableLinkListResultAdvancePage func(context.Context, BastionShareableLinkListResultResponse) (*azcore.Request, error)

type bastionShareableLinkListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester bastionShareableLinkListResultCreateRequest
	// callback for handling response errors
	errorer bastionShareableLinkListResultHandleError
	// callback for handling the HTTP response
	responder bastionShareableLinkListResultHandleResponse
	// callback for advancing to the next page
	advancer bastionShareableLinkListResultAdvancePage
	// contains the current response
	current BastionShareableLinkListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
	// previous response from the endpoint (LRO case)
	resp *azcore.Response
}

func (p *bastionShareableLinkListResultPager) Err() error {
	return p.err
}

func (p *bastionShareableLinkListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.BastionShareableLinkListResult.NextLink == nil || len(*p.current.BastionShareableLinkListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else if p.resp == nil {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp := p.resp
	if resp == nil {
		resp, err = p.pipeline.Do(req)
	} else {
		p.resp = nil
	}
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *bastionShareableLinkListResultPager) PageResponse() BastionShareableLinkListResultResponse {
	return p.current
}

// BgpServiceCommunityListResultPager provides iteration over BgpServiceCommunityListResult pages.
type BgpServiceCommunityListResultPager interface {
	azcore.Pager

	// PageResponse returns the current BgpServiceCommunityListResultResponse.
	PageResponse() BgpServiceCommunityListResultResponse
}

type bgpServiceCommunityListResultCreateRequest func(context.Context) (*azcore.Request, error)

type bgpServiceCommunityListResultHandleError func(*azcore.Response) error

type bgpServiceCommunityListResultHandleResponse func(*azcore.Response) (BgpServiceCommunityListResultResponse, error)

type bgpServiceCommunityListResultAdvancePage func(context.Context, BgpServiceCommunityListResultResponse) (*azcore.Request, error)

type bgpServiceCommunityListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester bgpServiceCommunityListResultCreateRequest
	// callback for handling response errors
	errorer bgpServiceCommunityListResultHandleError
	// callback for handling the HTTP response
	responder bgpServiceCommunityListResultHandleResponse
	// callback for advancing to the next page
	advancer bgpServiceCommunityListResultAdvancePage
	// contains the current response
	current BgpServiceCommunityListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *bgpServiceCommunityListResultPager) Err() error {
	return p.err
}

func (p *bgpServiceCommunityListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.BgpServiceCommunityListResult.NextLink == nil || len(*p.current.BgpServiceCommunityListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *bgpServiceCommunityListResultPager) PageResponse() BgpServiceCommunityListResultResponse {
	return p.current
}

// CustomIPPrefixListResultPager provides iteration over CustomIPPrefixListResult pages.
type CustomIPPrefixListResultPager interface {
	azcore.Pager

	// PageResponse returns the current CustomIPPrefixListResultResponse.
	PageResponse() CustomIPPrefixListResultResponse
}

type customIPPrefixListResultCreateRequest func(context.Context) (*azcore.Request, error)

type customIPPrefixListResultHandleError func(*azcore.Response) error

type customIPPrefixListResultHandleResponse func(*azcore.Response) (CustomIPPrefixListResultResponse, error)

type customIPPrefixListResultAdvancePage func(context.Context, CustomIPPrefixListResultResponse) (*azcore.Request, error)

type customIPPrefixListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester customIPPrefixListResultCreateRequest
	// callback for handling response errors
	errorer customIPPrefixListResultHandleError
	// callback for handling the HTTP response
	responder customIPPrefixListResultHandleResponse
	// callback for advancing to the next page
	advancer customIPPrefixListResultAdvancePage
	// contains the current response
	current CustomIPPrefixListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *customIPPrefixListResultPager) Err() error {
	return p.err
}

func (p *customIPPrefixListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.CustomIPPrefixListResult.NextLink == nil || len(*p.current.CustomIPPrefixListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *customIPPrefixListResultPager) PageResponse() CustomIPPrefixListResultResponse {
	return p.current
}

// DdosProtectionPlanListResultPager provides iteration over DdosProtectionPlanListResult pages.
type DdosProtectionPlanListResultPager interface {
	azcore.Pager

	// PageResponse returns the current DdosProtectionPlanListResultResponse.
	PageResponse() DdosProtectionPlanListResultResponse
}

type ddosProtectionPlanListResultCreateRequest func(context.Context) (*azcore.Request, error)

type ddosProtectionPlanListResultHandleError func(*azcore.Response) error

type ddosProtectionPlanListResultHandleResponse func(*azcore.Response) (DdosProtectionPlanListResultResponse, error)

type ddosProtectionPlanListResultAdvancePage func(context.Context, DdosProtectionPlanListResultResponse) (*azcore.Request, error)

type ddosProtectionPlanListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester ddosProtectionPlanListResultCreateRequest
	// callback for handling response errors
	errorer ddosProtectionPlanListResultHandleError
	// callback for handling the HTTP response
	responder ddosProtectionPlanListResultHandleResponse
	// callback for advancing to the next page
	advancer ddosProtectionPlanListResultAdvancePage
	// contains the current response
	current DdosProtectionPlanListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *ddosProtectionPlanListResultPager) Err() error {
	return p.err
}

func (p *ddosProtectionPlanListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DdosProtectionPlanListResult.NextLink == nil || len(*p.current.DdosProtectionPlanListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *ddosProtectionPlanListResultPager) PageResponse() DdosProtectionPlanListResultResponse {
	return p.current
}

// DscpConfigurationListResultPager provides iteration over DscpConfigurationListResult pages.
type DscpConfigurationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current DscpConfigurationListResultResponse.
	PageResponse() DscpConfigurationListResultResponse
}

type dscpConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type dscpConfigurationListResultHandleError func(*azcore.Response) error

type dscpConfigurationListResultHandleResponse func(*azcore.Response) (DscpConfigurationListResultResponse, error)

type dscpConfigurationListResultAdvancePage func(context.Context, DscpConfigurationListResultResponse) (*azcore.Request, error)

type dscpConfigurationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester dscpConfigurationListResultCreateRequest
	// callback for handling response errors
	errorer dscpConfigurationListResultHandleError
	// callback for handling the HTTP response
	responder dscpConfigurationListResultHandleResponse
	// callback for advancing to the next page
	advancer dscpConfigurationListResultAdvancePage
	// contains the current response
	current DscpConfigurationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *dscpConfigurationListResultPager) Err() error {
	return p.err
}

func (p *dscpConfigurationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DscpConfigurationListResult.NextLink == nil || len(*p.current.DscpConfigurationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *dscpConfigurationListResultPager) PageResponse() DscpConfigurationListResultResponse {
	return p.current
}

// EndpointServicesListResultPager provides iteration over EndpointServicesListResult pages.
type EndpointServicesListResultPager interface {
	azcore.Pager

	// PageResponse returns the current EndpointServicesListResultResponse.
	PageResponse() EndpointServicesListResultResponse
}

type endpointServicesListResultCreateRequest func(context.Context) (*azcore.Request, error)

type endpointServicesListResultHandleError func(*azcore.Response) error

type endpointServicesListResultHandleResponse func(*azcore.Response) (EndpointServicesListResultResponse, error)

type endpointServicesListResultAdvancePage func(context.Context, EndpointServicesListResultResponse) (*azcore.Request, error)

type endpointServicesListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester endpointServicesListResultCreateRequest
	// callback for handling response errors
	errorer endpointServicesListResultHandleError
	// callback for handling the HTTP response
	responder endpointServicesListResultHandleResponse
	// callback for advancing to the next page
	advancer endpointServicesListResultAdvancePage
	// contains the current response
	current EndpointServicesListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *endpointServicesListResultPager) Err() error {
	return p.err
}

func (p *endpointServicesListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.EndpointServicesListResult.NextLink == nil || len(*p.current.EndpointServicesListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *endpointServicesListResultPager) PageResponse() EndpointServicesListResultResponse {
	return p.current
}

// ExpressRouteCircuitConnectionListResultPager provides iteration over ExpressRouteCircuitConnectionListResult pages.
type ExpressRouteCircuitConnectionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRouteCircuitConnectionListResultResponse.
	PageResponse() ExpressRouteCircuitConnectionListResultResponse
}

type expressRouteCircuitConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRouteCircuitConnectionListResultHandleError func(*azcore.Response) error

type expressRouteCircuitConnectionListResultHandleResponse func(*azcore.Response) (ExpressRouteCircuitConnectionListResultResponse, error)

type expressRouteCircuitConnectionListResultAdvancePage func(context.Context, ExpressRouteCircuitConnectionListResultResponse) (*azcore.Request, error)

type expressRouteCircuitConnectionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRouteCircuitConnectionListResultCreateRequest
	// callback for handling response errors
	errorer expressRouteCircuitConnectionListResultHandleError
	// callback for handling the HTTP response
	responder expressRouteCircuitConnectionListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRouteCircuitConnectionListResultAdvancePage
	// contains the current response
	current ExpressRouteCircuitConnectionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRouteCircuitConnectionListResultPager) Err() error {
	return p.err
}

func (p *expressRouteCircuitConnectionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRouteCircuitConnectionListResult.NextLink == nil || len(*p.current.ExpressRouteCircuitConnectionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRouteCircuitConnectionListResultPager) PageResponse() ExpressRouteCircuitConnectionListResultResponse {
	return p.current
}

// ExpressRouteCircuitListResultPager provides iteration over ExpressRouteCircuitListResult pages.
type ExpressRouteCircuitListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRouteCircuitListResultResponse.
	PageResponse() ExpressRouteCircuitListResultResponse
}

type expressRouteCircuitListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRouteCircuitListResultHandleError func(*azcore.Response) error

type expressRouteCircuitListResultHandleResponse func(*azcore.Response) (ExpressRouteCircuitListResultResponse, error)

type expressRouteCircuitListResultAdvancePage func(context.Context, ExpressRouteCircuitListResultResponse) (*azcore.Request, error)

type expressRouteCircuitListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRouteCircuitListResultCreateRequest
	// callback for handling response errors
	errorer expressRouteCircuitListResultHandleError
	// callback for handling the HTTP response
	responder expressRouteCircuitListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRouteCircuitListResultAdvancePage
	// contains the current response
	current ExpressRouteCircuitListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRouteCircuitListResultPager) Err() error {
	return p.err
}

func (p *expressRouteCircuitListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRouteCircuitListResult.NextLink == nil || len(*p.current.ExpressRouteCircuitListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRouteCircuitListResultPager) PageResponse() ExpressRouteCircuitListResultResponse {
	return p.current
}

// ExpressRouteCircuitPeeringListResultPager provides iteration over ExpressRouteCircuitPeeringListResult pages.
type ExpressRouteCircuitPeeringListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRouteCircuitPeeringListResultResponse.
	PageResponse() ExpressRouteCircuitPeeringListResultResponse
}

type expressRouteCircuitPeeringListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRouteCircuitPeeringListResultHandleError func(*azcore.Response) error

type expressRouteCircuitPeeringListResultHandleResponse func(*azcore.Response) (ExpressRouteCircuitPeeringListResultResponse, error)

type expressRouteCircuitPeeringListResultAdvancePage func(context.Context, ExpressRouteCircuitPeeringListResultResponse) (*azcore.Request, error)

type expressRouteCircuitPeeringListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRouteCircuitPeeringListResultCreateRequest
	// callback for handling response errors
	errorer expressRouteCircuitPeeringListResultHandleError
	// callback for handling the HTTP response
	responder expressRouteCircuitPeeringListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRouteCircuitPeeringListResultAdvancePage
	// contains the current response
	current ExpressRouteCircuitPeeringListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRouteCircuitPeeringListResultPager) Err() error {
	return p.err
}

func (p *expressRouteCircuitPeeringListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRouteCircuitPeeringListResult.NextLink == nil || len(*p.current.ExpressRouteCircuitPeeringListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRouteCircuitPeeringListResultPager) PageResponse() ExpressRouteCircuitPeeringListResultResponse {
	return p.current
}

// ExpressRouteCrossConnectionListResultPager provides iteration over ExpressRouteCrossConnectionListResult pages.
type ExpressRouteCrossConnectionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRouteCrossConnectionListResultResponse.
	PageResponse() ExpressRouteCrossConnectionListResultResponse
}

type expressRouteCrossConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRouteCrossConnectionListResultHandleError func(*azcore.Response) error

type expressRouteCrossConnectionListResultHandleResponse func(*azcore.Response) (ExpressRouteCrossConnectionListResultResponse, error)

type expressRouteCrossConnectionListResultAdvancePage func(context.Context, ExpressRouteCrossConnectionListResultResponse) (*azcore.Request, error)

type expressRouteCrossConnectionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRouteCrossConnectionListResultCreateRequest
	// callback for handling response errors
	errorer expressRouteCrossConnectionListResultHandleError
	// callback for handling the HTTP response
	responder expressRouteCrossConnectionListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRouteCrossConnectionListResultAdvancePage
	// contains the current response
	current ExpressRouteCrossConnectionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRouteCrossConnectionListResultPager) Err() error {
	return p.err
}

func (p *expressRouteCrossConnectionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRouteCrossConnectionListResult.NextLink == nil || len(*p.current.ExpressRouteCrossConnectionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRouteCrossConnectionListResultPager) PageResponse() ExpressRouteCrossConnectionListResultResponse {
	return p.current
}

// ExpressRouteCrossConnectionPeeringListPager provides iteration over ExpressRouteCrossConnectionPeeringList pages.
type ExpressRouteCrossConnectionPeeringListPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRouteCrossConnectionPeeringListResponse.
	PageResponse() ExpressRouteCrossConnectionPeeringListResponse
}

type expressRouteCrossConnectionPeeringListCreateRequest func(context.Context) (*azcore.Request, error)

type expressRouteCrossConnectionPeeringListHandleError func(*azcore.Response) error

type expressRouteCrossConnectionPeeringListHandleResponse func(*azcore.Response) (ExpressRouteCrossConnectionPeeringListResponse, error)

type expressRouteCrossConnectionPeeringListAdvancePage func(context.Context, ExpressRouteCrossConnectionPeeringListResponse) (*azcore.Request, error)

type expressRouteCrossConnectionPeeringListPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRouteCrossConnectionPeeringListCreateRequest
	// callback for handling response errors
	errorer expressRouteCrossConnectionPeeringListHandleError
	// callback for handling the HTTP response
	responder expressRouteCrossConnectionPeeringListHandleResponse
	// callback for advancing to the next page
	advancer expressRouteCrossConnectionPeeringListAdvancePage
	// contains the current response
	current ExpressRouteCrossConnectionPeeringListResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRouteCrossConnectionPeeringListPager) Err() error {
	return p.err
}

func (p *expressRouteCrossConnectionPeeringListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRouteCrossConnectionPeeringList.NextLink == nil || len(*p.current.ExpressRouteCrossConnectionPeeringList.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRouteCrossConnectionPeeringListPager) PageResponse() ExpressRouteCrossConnectionPeeringListResponse {
	return p.current
}

// ExpressRouteLinkListResultPager provides iteration over ExpressRouteLinkListResult pages.
type ExpressRouteLinkListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRouteLinkListResultResponse.
	PageResponse() ExpressRouteLinkListResultResponse
}

type expressRouteLinkListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRouteLinkListResultHandleError func(*azcore.Response) error

type expressRouteLinkListResultHandleResponse func(*azcore.Response) (ExpressRouteLinkListResultResponse, error)

type expressRouteLinkListResultAdvancePage func(context.Context, ExpressRouteLinkListResultResponse) (*azcore.Request, error)

type expressRouteLinkListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRouteLinkListResultCreateRequest
	// callback for handling response errors
	errorer expressRouteLinkListResultHandleError
	// callback for handling the HTTP response
	responder expressRouteLinkListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRouteLinkListResultAdvancePage
	// contains the current response
	current ExpressRouteLinkListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRouteLinkListResultPager) Err() error {
	return p.err
}

func (p *expressRouteLinkListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRouteLinkListResult.NextLink == nil || len(*p.current.ExpressRouteLinkListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRouteLinkListResultPager) PageResponse() ExpressRouteLinkListResultResponse {
	return p.current
}

// ExpressRoutePortListResultPager provides iteration over ExpressRoutePortListResult pages.
type ExpressRoutePortListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRoutePortListResultResponse.
	PageResponse() ExpressRoutePortListResultResponse
}

type expressRoutePortListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRoutePortListResultHandleError func(*azcore.Response) error

type expressRoutePortListResultHandleResponse func(*azcore.Response) (ExpressRoutePortListResultResponse, error)

type expressRoutePortListResultAdvancePage func(context.Context, ExpressRoutePortListResultResponse) (*azcore.Request, error)

type expressRoutePortListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRoutePortListResultCreateRequest
	// callback for handling response errors
	errorer expressRoutePortListResultHandleError
	// callback for handling the HTTP response
	responder expressRoutePortListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRoutePortListResultAdvancePage
	// contains the current response
	current ExpressRoutePortListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRoutePortListResultPager) Err() error {
	return p.err
}

func (p *expressRoutePortListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRoutePortListResult.NextLink == nil || len(*p.current.ExpressRoutePortListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRoutePortListResultPager) PageResponse() ExpressRoutePortListResultResponse {
	return p.current
}

// ExpressRoutePortsLocationListResultPager provides iteration over ExpressRoutePortsLocationListResult pages.
type ExpressRoutePortsLocationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRoutePortsLocationListResultResponse.
	PageResponse() ExpressRoutePortsLocationListResultResponse
}

type expressRoutePortsLocationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRoutePortsLocationListResultHandleError func(*azcore.Response) error

type expressRoutePortsLocationListResultHandleResponse func(*azcore.Response) (ExpressRoutePortsLocationListResultResponse, error)

type expressRoutePortsLocationListResultAdvancePage func(context.Context, ExpressRoutePortsLocationListResultResponse) (*azcore.Request, error)

type expressRoutePortsLocationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRoutePortsLocationListResultCreateRequest
	// callback for handling response errors
	errorer expressRoutePortsLocationListResultHandleError
	// callback for handling the HTTP response
	responder expressRoutePortsLocationListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRoutePortsLocationListResultAdvancePage
	// contains the current response
	current ExpressRoutePortsLocationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRoutePortsLocationListResultPager) Err() error {
	return p.err
}

func (p *expressRoutePortsLocationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRoutePortsLocationListResult.NextLink == nil || len(*p.current.ExpressRoutePortsLocationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRoutePortsLocationListResultPager) PageResponse() ExpressRoutePortsLocationListResultResponse {
	return p.current
}

// ExpressRouteServiceProviderListResultPager provides iteration over ExpressRouteServiceProviderListResult pages.
type ExpressRouteServiceProviderListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ExpressRouteServiceProviderListResultResponse.
	PageResponse() ExpressRouteServiceProviderListResultResponse
}

type expressRouteServiceProviderListResultCreateRequest func(context.Context) (*azcore.Request, error)

type expressRouteServiceProviderListResultHandleError func(*azcore.Response) error

type expressRouteServiceProviderListResultHandleResponse func(*azcore.Response) (ExpressRouteServiceProviderListResultResponse, error)

type expressRouteServiceProviderListResultAdvancePage func(context.Context, ExpressRouteServiceProviderListResultResponse) (*azcore.Request, error)

type expressRouteServiceProviderListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester expressRouteServiceProviderListResultCreateRequest
	// callback for handling response errors
	errorer expressRouteServiceProviderListResultHandleError
	// callback for handling the HTTP response
	responder expressRouteServiceProviderListResultHandleResponse
	// callback for advancing to the next page
	advancer expressRouteServiceProviderListResultAdvancePage
	// contains the current response
	current ExpressRouteServiceProviderListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *expressRouteServiceProviderListResultPager) Err() error {
	return p.err
}

func (p *expressRouteServiceProviderListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ExpressRouteServiceProviderListResult.NextLink == nil || len(*p.current.ExpressRouteServiceProviderListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *expressRouteServiceProviderListResultPager) PageResponse() ExpressRouteServiceProviderListResultResponse {
	return p.current
}

// FirewallPolicyListResultPager provides iteration over FirewallPolicyListResult pages.
type FirewallPolicyListResultPager interface {
	azcore.Pager

	// PageResponse returns the current FirewallPolicyListResultResponse.
	PageResponse() FirewallPolicyListResultResponse
}

type firewallPolicyListResultCreateRequest func(context.Context) (*azcore.Request, error)

type firewallPolicyListResultHandleError func(*azcore.Response) error

type firewallPolicyListResultHandleResponse func(*azcore.Response) (FirewallPolicyListResultResponse, error)

type firewallPolicyListResultAdvancePage func(context.Context, FirewallPolicyListResultResponse) (*azcore.Request, error)

type firewallPolicyListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester firewallPolicyListResultCreateRequest
	// callback for handling response errors
	errorer firewallPolicyListResultHandleError
	// callback for handling the HTTP response
	responder firewallPolicyListResultHandleResponse
	// callback for advancing to the next page
	advancer firewallPolicyListResultAdvancePage
	// contains the current response
	current FirewallPolicyListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *firewallPolicyListResultPager) Err() error {
	return p.err
}

func (p *firewallPolicyListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.FirewallPolicyListResult.NextLink == nil || len(*p.current.FirewallPolicyListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *firewallPolicyListResultPager) PageResponse() FirewallPolicyListResultResponse {
	return p.current
}

// FirewallPolicyRuleCollectionGroupListResultPager provides iteration over FirewallPolicyRuleCollectionGroupListResult pages.
type FirewallPolicyRuleCollectionGroupListResultPager interface {
	azcore.Pager

	// PageResponse returns the current FirewallPolicyRuleCollectionGroupListResultResponse.
	PageResponse() FirewallPolicyRuleCollectionGroupListResultResponse
}

type firewallPolicyRuleCollectionGroupListResultCreateRequest func(context.Context) (*azcore.Request, error)

type firewallPolicyRuleCollectionGroupListResultHandleError func(*azcore.Response) error

type firewallPolicyRuleCollectionGroupListResultHandleResponse func(*azcore.Response) (FirewallPolicyRuleCollectionGroupListResultResponse, error)

type firewallPolicyRuleCollectionGroupListResultAdvancePage func(context.Context, FirewallPolicyRuleCollectionGroupListResultResponse) (*azcore.Request, error)

type firewallPolicyRuleCollectionGroupListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester firewallPolicyRuleCollectionGroupListResultCreateRequest
	// callback for handling response errors
	errorer firewallPolicyRuleCollectionGroupListResultHandleError
	// callback for handling the HTTP response
	responder firewallPolicyRuleCollectionGroupListResultHandleResponse
	// callback for advancing to the next page
	advancer firewallPolicyRuleCollectionGroupListResultAdvancePage
	// contains the current response
	current FirewallPolicyRuleCollectionGroupListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *firewallPolicyRuleCollectionGroupListResultPager) Err() error {
	return p.err
}

func (p *firewallPolicyRuleCollectionGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.FirewallPolicyRuleCollectionGroupListResult.NextLink == nil || len(*p.current.FirewallPolicyRuleCollectionGroupListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *firewallPolicyRuleCollectionGroupListResultPager) PageResponse() FirewallPolicyRuleCollectionGroupListResultResponse {
	return p.current
}

// FlowLogListResultPager provides iteration over FlowLogListResult pages.
type FlowLogListResultPager interface {
	azcore.Pager

	// PageResponse returns the current FlowLogListResultResponse.
	PageResponse() FlowLogListResultResponse
}

type flowLogListResultCreateRequest func(context.Context) (*azcore.Request, error)

type flowLogListResultHandleError func(*azcore.Response) error

type flowLogListResultHandleResponse func(*azcore.Response) (FlowLogListResultResponse, error)

type flowLogListResultAdvancePage func(context.Context, FlowLogListResultResponse) (*azcore.Request, error)

type flowLogListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester flowLogListResultCreateRequest
	// callback for handling response errors
	errorer flowLogListResultHandleError
	// callback for handling the HTTP response
	responder flowLogListResultHandleResponse
	// callback for advancing to the next page
	advancer flowLogListResultAdvancePage
	// contains the current response
	current FlowLogListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *flowLogListResultPager) Err() error {
	return p.err
}

func (p *flowLogListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.FlowLogListResult.NextLink == nil || len(*p.current.FlowLogListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *flowLogListResultPager) PageResponse() FlowLogListResultResponse {
	return p.current
}

// IPAllocationListResultPager provides iteration over IPAllocationListResult pages.
type IPAllocationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current IPAllocationListResultResponse.
	PageResponse() IPAllocationListResultResponse
}

type ipAllocationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type ipAllocationListResultHandleError func(*azcore.Response) error

type ipAllocationListResultHandleResponse func(*azcore.Response) (IPAllocationListResultResponse, error)

type ipAllocationListResultAdvancePage func(context.Context, IPAllocationListResultResponse) (*azcore.Request, error)

type ipAllocationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester ipAllocationListResultCreateRequest
	// callback for handling response errors
	errorer ipAllocationListResultHandleError
	// callback for handling the HTTP response
	responder ipAllocationListResultHandleResponse
	// callback for advancing to the next page
	advancer ipAllocationListResultAdvancePage
	// contains the current response
	current IPAllocationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *ipAllocationListResultPager) Err() error {
	return p.err
}

func (p *ipAllocationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.IPAllocationListResult.NextLink == nil || len(*p.current.IPAllocationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *ipAllocationListResultPager) PageResponse() IPAllocationListResultResponse {
	return p.current
}

// IPGroupListResultPager provides iteration over IPGroupListResult pages.
type IPGroupListResultPager interface {
	azcore.Pager

	// PageResponse returns the current IPGroupListResultResponse.
	PageResponse() IPGroupListResultResponse
}

type ipGroupListResultCreateRequest func(context.Context) (*azcore.Request, error)

type ipGroupListResultHandleError func(*azcore.Response) error

type ipGroupListResultHandleResponse func(*azcore.Response) (IPGroupListResultResponse, error)

type ipGroupListResultAdvancePage func(context.Context, IPGroupListResultResponse) (*azcore.Request, error)

type ipGroupListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester ipGroupListResultCreateRequest
	// callback for handling response errors
	errorer ipGroupListResultHandleError
	// callback for handling the HTTP response
	responder ipGroupListResultHandleResponse
	// callback for advancing to the next page
	advancer ipGroupListResultAdvancePage
	// contains the current response
	current IPGroupListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *ipGroupListResultPager) Err() error {
	return p.err
}

func (p *ipGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.IPGroupListResult.NextLink == nil || len(*p.current.IPGroupListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *ipGroupListResultPager) PageResponse() IPGroupListResultResponse {
	return p.current
}

// InboundNatRuleListResultPager provides iteration over InboundNatRuleListResult pages.
type InboundNatRuleListResultPager interface {
	azcore.Pager

	// PageResponse returns the current InboundNatRuleListResultResponse.
	PageResponse() InboundNatRuleListResultResponse
}

type inboundNatRuleListResultCreateRequest func(context.Context) (*azcore.Request, error)

type inboundNatRuleListResultHandleError func(*azcore.Response) error

type inboundNatRuleListResultHandleResponse func(*azcore.Response) (InboundNatRuleListResultResponse, error)

type inboundNatRuleListResultAdvancePage func(context.Context, InboundNatRuleListResultResponse) (*azcore.Request, error)

type inboundNatRuleListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester inboundNatRuleListResultCreateRequest
	// callback for handling response errors
	errorer inboundNatRuleListResultHandleError
	// callback for handling the HTTP response
	responder inboundNatRuleListResultHandleResponse
	// callback for advancing to the next page
	advancer inboundNatRuleListResultAdvancePage
	// contains the current response
	current InboundNatRuleListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *inboundNatRuleListResultPager) Err() error {
	return p.err
}

func (p *inboundNatRuleListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.InboundNatRuleListResult.NextLink == nil || len(*p.current.InboundNatRuleListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *inboundNatRuleListResultPager) PageResponse() InboundNatRuleListResultResponse {
	return p.current
}

// ListHubRouteTablesResultPager provides iteration over ListHubRouteTablesResult pages.
type ListHubRouteTablesResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListHubRouteTablesResultResponse.
	PageResponse() ListHubRouteTablesResultResponse
}

type listHubRouteTablesResultCreateRequest func(context.Context) (*azcore.Request, error)

type listHubRouteTablesResultHandleError func(*azcore.Response) error

type listHubRouteTablesResultHandleResponse func(*azcore.Response) (ListHubRouteTablesResultResponse, error)

type listHubRouteTablesResultAdvancePage func(context.Context, ListHubRouteTablesResultResponse) (*azcore.Request, error)

type listHubRouteTablesResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listHubRouteTablesResultCreateRequest
	// callback for handling response errors
	errorer listHubRouteTablesResultHandleError
	// callback for handling the HTTP response
	responder listHubRouteTablesResultHandleResponse
	// callback for advancing to the next page
	advancer listHubRouteTablesResultAdvancePage
	// contains the current response
	current ListHubRouteTablesResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listHubRouteTablesResultPager) Err() error {
	return p.err
}

func (p *listHubRouteTablesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListHubRouteTablesResult.NextLink == nil || len(*p.current.ListHubRouteTablesResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listHubRouteTablesResultPager) PageResponse() ListHubRouteTablesResultResponse {
	return p.current
}

// ListHubVirtualNetworkConnectionsResultPager provides iteration over ListHubVirtualNetworkConnectionsResult pages.
type ListHubVirtualNetworkConnectionsResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListHubVirtualNetworkConnectionsResultResponse.
	PageResponse() ListHubVirtualNetworkConnectionsResultResponse
}

type listHubVirtualNetworkConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error)

type listHubVirtualNetworkConnectionsResultHandleError func(*azcore.Response) error

type listHubVirtualNetworkConnectionsResultHandleResponse func(*azcore.Response) (ListHubVirtualNetworkConnectionsResultResponse, error)

type listHubVirtualNetworkConnectionsResultAdvancePage func(context.Context, ListHubVirtualNetworkConnectionsResultResponse) (*azcore.Request, error)

type listHubVirtualNetworkConnectionsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listHubVirtualNetworkConnectionsResultCreateRequest
	// callback for handling response errors
	errorer listHubVirtualNetworkConnectionsResultHandleError
	// callback for handling the HTTP response
	responder listHubVirtualNetworkConnectionsResultHandleResponse
	// callback for advancing to the next page
	advancer listHubVirtualNetworkConnectionsResultAdvancePage
	// contains the current response
	current ListHubVirtualNetworkConnectionsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listHubVirtualNetworkConnectionsResultPager) Err() error {
	return p.err
}

func (p *listHubVirtualNetworkConnectionsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListHubVirtualNetworkConnectionsResult.NextLink == nil || len(*p.current.ListHubVirtualNetworkConnectionsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listHubVirtualNetworkConnectionsResultPager) PageResponse() ListHubVirtualNetworkConnectionsResultResponse {
	return p.current
}

// ListP2SVPNGatewaysResultPager provides iteration over ListP2SVPNGatewaysResult pages.
type ListP2SVPNGatewaysResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListP2SVPNGatewaysResultResponse.
	PageResponse() ListP2SVPNGatewaysResultResponse
}

type listP2SVPNGatewaysResultCreateRequest func(context.Context) (*azcore.Request, error)

type listP2SVPNGatewaysResultHandleError func(*azcore.Response) error

type listP2SVPNGatewaysResultHandleResponse func(*azcore.Response) (ListP2SVPNGatewaysResultResponse, error)

type listP2SVPNGatewaysResultAdvancePage func(context.Context, ListP2SVPNGatewaysResultResponse) (*azcore.Request, error)

type listP2SVPNGatewaysResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listP2SVPNGatewaysResultCreateRequest
	// callback for handling response errors
	errorer listP2SVPNGatewaysResultHandleError
	// callback for handling the HTTP response
	responder listP2SVPNGatewaysResultHandleResponse
	// callback for advancing to the next page
	advancer listP2SVPNGatewaysResultAdvancePage
	// contains the current response
	current ListP2SVPNGatewaysResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listP2SVPNGatewaysResultPager) Err() error {
	return p.err
}

func (p *listP2SVPNGatewaysResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListP2SVPNGatewaysResult.NextLink == nil || len(*p.current.ListP2SVPNGatewaysResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listP2SVPNGatewaysResultPager) PageResponse() ListP2SVPNGatewaysResultResponse {
	return p.current
}

// ListVPNConnectionsResultPager provides iteration over ListVPNConnectionsResult pages.
type ListVPNConnectionsResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVPNConnectionsResultResponse.
	PageResponse() ListVPNConnectionsResultResponse
}

type listVPNConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVPNConnectionsResultHandleError func(*azcore.Response) error

type listVPNConnectionsResultHandleResponse func(*azcore.Response) (ListVPNConnectionsResultResponse, error)

type listVPNConnectionsResultAdvancePage func(context.Context, ListVPNConnectionsResultResponse) (*azcore.Request, error)

type listVPNConnectionsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVPNConnectionsResultCreateRequest
	// callback for handling response errors
	errorer listVPNConnectionsResultHandleError
	// callback for handling the HTTP response
	responder listVPNConnectionsResultHandleResponse
	// callback for advancing to the next page
	advancer listVPNConnectionsResultAdvancePage
	// contains the current response
	current ListVPNConnectionsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVPNConnectionsResultPager) Err() error {
	return p.err
}

func (p *listVPNConnectionsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVPNConnectionsResult.NextLink == nil || len(*p.current.ListVPNConnectionsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVPNConnectionsResultPager) PageResponse() ListVPNConnectionsResultResponse {
	return p.current
}

// ListVPNGatewayNatRulesResultPager provides iteration over ListVPNGatewayNatRulesResult pages.
type ListVPNGatewayNatRulesResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVPNGatewayNatRulesResultResponse.
	PageResponse() ListVPNGatewayNatRulesResultResponse
}

type listVPNGatewayNatRulesResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVPNGatewayNatRulesResultHandleError func(*azcore.Response) error

type listVPNGatewayNatRulesResultHandleResponse func(*azcore.Response) (ListVPNGatewayNatRulesResultResponse, error)

type listVPNGatewayNatRulesResultAdvancePage func(context.Context, ListVPNGatewayNatRulesResultResponse) (*azcore.Request, error)

type listVPNGatewayNatRulesResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVPNGatewayNatRulesResultCreateRequest
	// callback for handling response errors
	errorer listVPNGatewayNatRulesResultHandleError
	// callback for handling the HTTP response
	responder listVPNGatewayNatRulesResultHandleResponse
	// callback for advancing to the next page
	advancer listVPNGatewayNatRulesResultAdvancePage
	// contains the current response
	current ListVPNGatewayNatRulesResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVPNGatewayNatRulesResultPager) Err() error {
	return p.err
}

func (p *listVPNGatewayNatRulesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVPNGatewayNatRulesResult.NextLink == nil || len(*p.current.ListVPNGatewayNatRulesResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVPNGatewayNatRulesResultPager) PageResponse() ListVPNGatewayNatRulesResultResponse {
	return p.current
}

// ListVPNGatewaysResultPager provides iteration over ListVPNGatewaysResult pages.
type ListVPNGatewaysResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVPNGatewaysResultResponse.
	PageResponse() ListVPNGatewaysResultResponse
}

type listVPNGatewaysResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVPNGatewaysResultHandleError func(*azcore.Response) error

type listVPNGatewaysResultHandleResponse func(*azcore.Response) (ListVPNGatewaysResultResponse, error)

type listVPNGatewaysResultAdvancePage func(context.Context, ListVPNGatewaysResultResponse) (*azcore.Request, error)

type listVPNGatewaysResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVPNGatewaysResultCreateRequest
	// callback for handling response errors
	errorer listVPNGatewaysResultHandleError
	// callback for handling the HTTP response
	responder listVPNGatewaysResultHandleResponse
	// callback for advancing to the next page
	advancer listVPNGatewaysResultAdvancePage
	// contains the current response
	current ListVPNGatewaysResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVPNGatewaysResultPager) Err() error {
	return p.err
}

func (p *listVPNGatewaysResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVPNGatewaysResult.NextLink == nil || len(*p.current.ListVPNGatewaysResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVPNGatewaysResultPager) PageResponse() ListVPNGatewaysResultResponse {
	return p.current
}

// ListVPNServerConfigurationsResultPager provides iteration over ListVPNServerConfigurationsResult pages.
type ListVPNServerConfigurationsResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVPNServerConfigurationsResultResponse.
	PageResponse() ListVPNServerConfigurationsResultResponse
}

type listVPNServerConfigurationsResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVPNServerConfigurationsResultHandleError func(*azcore.Response) error

type listVPNServerConfigurationsResultHandleResponse func(*azcore.Response) (ListVPNServerConfigurationsResultResponse, error)

type listVPNServerConfigurationsResultAdvancePage func(context.Context, ListVPNServerConfigurationsResultResponse) (*azcore.Request, error)

type listVPNServerConfigurationsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVPNServerConfigurationsResultCreateRequest
	// callback for handling response errors
	errorer listVPNServerConfigurationsResultHandleError
	// callback for handling the HTTP response
	responder listVPNServerConfigurationsResultHandleResponse
	// callback for advancing to the next page
	advancer listVPNServerConfigurationsResultAdvancePage
	// contains the current response
	current ListVPNServerConfigurationsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVPNServerConfigurationsResultPager) Err() error {
	return p.err
}

func (p *listVPNServerConfigurationsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVPNServerConfigurationsResult.NextLink == nil || len(*p.current.ListVPNServerConfigurationsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVPNServerConfigurationsResultPager) PageResponse() ListVPNServerConfigurationsResultResponse {
	return p.current
}

// ListVPNSiteLinkConnectionsResultPager provides iteration over ListVPNSiteLinkConnectionsResult pages.
type ListVPNSiteLinkConnectionsResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVPNSiteLinkConnectionsResultResponse.
	PageResponse() ListVPNSiteLinkConnectionsResultResponse
}

type listVPNSiteLinkConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVPNSiteLinkConnectionsResultHandleError func(*azcore.Response) error

type listVPNSiteLinkConnectionsResultHandleResponse func(*azcore.Response) (ListVPNSiteLinkConnectionsResultResponse, error)

type listVPNSiteLinkConnectionsResultAdvancePage func(context.Context, ListVPNSiteLinkConnectionsResultResponse) (*azcore.Request, error)

type listVPNSiteLinkConnectionsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVPNSiteLinkConnectionsResultCreateRequest
	// callback for handling response errors
	errorer listVPNSiteLinkConnectionsResultHandleError
	// callback for handling the HTTP response
	responder listVPNSiteLinkConnectionsResultHandleResponse
	// callback for advancing to the next page
	advancer listVPNSiteLinkConnectionsResultAdvancePage
	// contains the current response
	current ListVPNSiteLinkConnectionsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVPNSiteLinkConnectionsResultPager) Err() error {
	return p.err
}

func (p *listVPNSiteLinkConnectionsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVPNSiteLinkConnectionsResult.NextLink == nil || len(*p.current.ListVPNSiteLinkConnectionsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVPNSiteLinkConnectionsResultPager) PageResponse() ListVPNSiteLinkConnectionsResultResponse {
	return p.current
}

// ListVPNSiteLinksResultPager provides iteration over ListVPNSiteLinksResult pages.
type ListVPNSiteLinksResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVPNSiteLinksResultResponse.
	PageResponse() ListVPNSiteLinksResultResponse
}

type listVPNSiteLinksResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVPNSiteLinksResultHandleError func(*azcore.Response) error

type listVPNSiteLinksResultHandleResponse func(*azcore.Response) (ListVPNSiteLinksResultResponse, error)

type listVPNSiteLinksResultAdvancePage func(context.Context, ListVPNSiteLinksResultResponse) (*azcore.Request, error)

type listVPNSiteLinksResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVPNSiteLinksResultCreateRequest
	// callback for handling response errors
	errorer listVPNSiteLinksResultHandleError
	// callback for handling the HTTP response
	responder listVPNSiteLinksResultHandleResponse
	// callback for advancing to the next page
	advancer listVPNSiteLinksResultAdvancePage
	// contains the current response
	current ListVPNSiteLinksResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVPNSiteLinksResultPager) Err() error {
	return p.err
}

func (p *listVPNSiteLinksResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVPNSiteLinksResult.NextLink == nil || len(*p.current.ListVPNSiteLinksResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVPNSiteLinksResultPager) PageResponse() ListVPNSiteLinksResultResponse {
	return p.current
}

// ListVPNSitesResultPager provides iteration over ListVPNSitesResult pages.
type ListVPNSitesResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVPNSitesResultResponse.
	PageResponse() ListVPNSitesResultResponse
}

type listVPNSitesResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVPNSitesResultHandleError func(*azcore.Response) error

type listVPNSitesResultHandleResponse func(*azcore.Response) (ListVPNSitesResultResponse, error)

type listVPNSitesResultAdvancePage func(context.Context, ListVPNSitesResultResponse) (*azcore.Request, error)

type listVPNSitesResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVPNSitesResultCreateRequest
	// callback for handling response errors
	errorer listVPNSitesResultHandleError
	// callback for handling the HTTP response
	responder listVPNSitesResultHandleResponse
	// callback for advancing to the next page
	advancer listVPNSitesResultAdvancePage
	// contains the current response
	current ListVPNSitesResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVPNSitesResultPager) Err() error {
	return p.err
}

func (p *listVPNSitesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVPNSitesResult.NextLink == nil || len(*p.current.ListVPNSitesResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVPNSitesResultPager) PageResponse() ListVPNSitesResultResponse {
	return p.current
}

// ListVirtualHubBgpConnectionResultsPager provides iteration over ListVirtualHubBgpConnectionResults pages.
type ListVirtualHubBgpConnectionResultsPager interface {
	azcore.Pager

	// PageResponse returns the current ListVirtualHubBgpConnectionResultsResponse.
	PageResponse() ListVirtualHubBgpConnectionResultsResponse
}

type listVirtualHubBgpConnectionResultsCreateRequest func(context.Context) (*azcore.Request, error)

type listVirtualHubBgpConnectionResultsHandleError func(*azcore.Response) error

type listVirtualHubBgpConnectionResultsHandleResponse func(*azcore.Response) (ListVirtualHubBgpConnectionResultsResponse, error)

type listVirtualHubBgpConnectionResultsAdvancePage func(context.Context, ListVirtualHubBgpConnectionResultsResponse) (*azcore.Request, error)

type listVirtualHubBgpConnectionResultsPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVirtualHubBgpConnectionResultsCreateRequest
	// callback for handling response errors
	errorer listVirtualHubBgpConnectionResultsHandleError
	// callback for handling the HTTP response
	responder listVirtualHubBgpConnectionResultsHandleResponse
	// callback for advancing to the next page
	advancer listVirtualHubBgpConnectionResultsAdvancePage
	// contains the current response
	current ListVirtualHubBgpConnectionResultsResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVirtualHubBgpConnectionResultsPager) Err() error {
	return p.err
}

func (p *listVirtualHubBgpConnectionResultsPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVirtualHubBgpConnectionResults.NextLink == nil || len(*p.current.ListVirtualHubBgpConnectionResults.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVirtualHubBgpConnectionResultsPager) PageResponse() ListVirtualHubBgpConnectionResultsResponse {
	return p.current
}

// ListVirtualHubIPConfigurationResultsPager provides iteration over ListVirtualHubIPConfigurationResults pages.
type ListVirtualHubIPConfigurationResultsPager interface {
	azcore.Pager

	// PageResponse returns the current ListVirtualHubIPConfigurationResultsResponse.
	PageResponse() ListVirtualHubIPConfigurationResultsResponse
}

type listVirtualHubIPConfigurationResultsCreateRequest func(context.Context) (*azcore.Request, error)

type listVirtualHubIPConfigurationResultsHandleError func(*azcore.Response) error

type listVirtualHubIPConfigurationResultsHandleResponse func(*azcore.Response) (ListVirtualHubIPConfigurationResultsResponse, error)

type listVirtualHubIPConfigurationResultsAdvancePage func(context.Context, ListVirtualHubIPConfigurationResultsResponse) (*azcore.Request, error)

type listVirtualHubIPConfigurationResultsPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVirtualHubIPConfigurationResultsCreateRequest
	// callback for handling response errors
	errorer listVirtualHubIPConfigurationResultsHandleError
	// callback for handling the HTTP response
	responder listVirtualHubIPConfigurationResultsHandleResponse
	// callback for advancing to the next page
	advancer listVirtualHubIPConfigurationResultsAdvancePage
	// contains the current response
	current ListVirtualHubIPConfigurationResultsResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVirtualHubIPConfigurationResultsPager) Err() error {
	return p.err
}

func (p *listVirtualHubIPConfigurationResultsPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVirtualHubIPConfigurationResults.NextLink == nil || len(*p.current.ListVirtualHubIPConfigurationResults.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVirtualHubIPConfigurationResultsPager) PageResponse() ListVirtualHubIPConfigurationResultsResponse {
	return p.current
}

// ListVirtualHubRouteTableV2SResultPager provides iteration over ListVirtualHubRouteTableV2SResult pages.
type ListVirtualHubRouteTableV2SResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVirtualHubRouteTableV2SResultResponse.
	PageResponse() ListVirtualHubRouteTableV2SResultResponse
}

type listVirtualHubRouteTableV2SResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVirtualHubRouteTableV2SResultHandleError func(*azcore.Response) error

type listVirtualHubRouteTableV2SResultHandleResponse func(*azcore.Response) (ListVirtualHubRouteTableV2SResultResponse, error)

type listVirtualHubRouteTableV2SResultAdvancePage func(context.Context, ListVirtualHubRouteTableV2SResultResponse) (*azcore.Request, error)

type listVirtualHubRouteTableV2SResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVirtualHubRouteTableV2SResultCreateRequest
	// callback for handling response errors
	errorer listVirtualHubRouteTableV2SResultHandleError
	// callback for handling the HTTP response
	responder listVirtualHubRouteTableV2SResultHandleResponse
	// callback for advancing to the next page
	advancer listVirtualHubRouteTableV2SResultAdvancePage
	// contains the current response
	current ListVirtualHubRouteTableV2SResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVirtualHubRouteTableV2SResultPager) Err() error {
	return p.err
}

func (p *listVirtualHubRouteTableV2SResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVirtualHubRouteTableV2SResult.NextLink == nil || len(*p.current.ListVirtualHubRouteTableV2SResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVirtualHubRouteTableV2SResultPager) PageResponse() ListVirtualHubRouteTableV2SResultResponse {
	return p.current
}

// ListVirtualHubsResultPager provides iteration over ListVirtualHubsResult pages.
type ListVirtualHubsResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVirtualHubsResultResponse.
	PageResponse() ListVirtualHubsResultResponse
}

type listVirtualHubsResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVirtualHubsResultHandleError func(*azcore.Response) error

type listVirtualHubsResultHandleResponse func(*azcore.Response) (ListVirtualHubsResultResponse, error)

type listVirtualHubsResultAdvancePage func(context.Context, ListVirtualHubsResultResponse) (*azcore.Request, error)

type listVirtualHubsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVirtualHubsResultCreateRequest
	// callback for handling response errors
	errorer listVirtualHubsResultHandleError
	// callback for handling the HTTP response
	responder listVirtualHubsResultHandleResponse
	// callback for advancing to the next page
	advancer listVirtualHubsResultAdvancePage
	// contains the current response
	current ListVirtualHubsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVirtualHubsResultPager) Err() error {
	return p.err
}

func (p *listVirtualHubsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVirtualHubsResult.NextLink == nil || len(*p.current.ListVirtualHubsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVirtualHubsResultPager) PageResponse() ListVirtualHubsResultResponse {
	return p.current
}

// ListVirtualNetworkGatewayNatRulesResultPager provides iteration over ListVirtualNetworkGatewayNatRulesResult pages.
type ListVirtualNetworkGatewayNatRulesResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVirtualNetworkGatewayNatRulesResultResponse.
	PageResponse() ListVirtualNetworkGatewayNatRulesResultResponse
}

type listVirtualNetworkGatewayNatRulesResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVirtualNetworkGatewayNatRulesResultHandleError func(*azcore.Response) error

type listVirtualNetworkGatewayNatRulesResultHandleResponse func(*azcore.Response) (ListVirtualNetworkGatewayNatRulesResultResponse, error)

type listVirtualNetworkGatewayNatRulesResultAdvancePage func(context.Context, ListVirtualNetworkGatewayNatRulesResultResponse) (*azcore.Request, error)

type listVirtualNetworkGatewayNatRulesResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVirtualNetworkGatewayNatRulesResultCreateRequest
	// callback for handling response errors
	errorer listVirtualNetworkGatewayNatRulesResultHandleError
	// callback for handling the HTTP response
	responder listVirtualNetworkGatewayNatRulesResultHandleResponse
	// callback for advancing to the next page
	advancer listVirtualNetworkGatewayNatRulesResultAdvancePage
	// contains the current response
	current ListVirtualNetworkGatewayNatRulesResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVirtualNetworkGatewayNatRulesResultPager) Err() error {
	return p.err
}

func (p *listVirtualNetworkGatewayNatRulesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVirtualNetworkGatewayNatRulesResult.NextLink == nil || len(*p.current.ListVirtualNetworkGatewayNatRulesResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVirtualNetworkGatewayNatRulesResultPager) PageResponse() ListVirtualNetworkGatewayNatRulesResultResponse {
	return p.current
}

// ListVirtualWANsResultPager provides iteration over ListVirtualWANsResult pages.
type ListVirtualWANsResultPager interface {
	azcore.Pager

	// PageResponse returns the current ListVirtualWANsResultResponse.
	PageResponse() ListVirtualWANsResultResponse
}

type listVirtualWANsResultCreateRequest func(context.Context) (*azcore.Request, error)

type listVirtualWANsResultHandleError func(*azcore.Response) error

type listVirtualWANsResultHandleResponse func(*azcore.Response) (ListVirtualWANsResultResponse, error)

type listVirtualWANsResultAdvancePage func(context.Context, ListVirtualWANsResultResponse) (*azcore.Request, error)

type listVirtualWANsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester listVirtualWANsResultCreateRequest
	// callback for handling response errors
	errorer listVirtualWANsResultHandleError
	// callback for handling the HTTP response
	responder listVirtualWANsResultHandleResponse
	// callback for advancing to the next page
	advancer listVirtualWANsResultAdvancePage
	// contains the current response
	current ListVirtualWANsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *listVirtualWANsResultPager) Err() error {
	return p.err
}

func (p *listVirtualWANsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListVirtualWANsResult.NextLink == nil || len(*p.current.ListVirtualWANsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *listVirtualWANsResultPager) PageResponse() ListVirtualWANsResultResponse {
	return p.current
}

// LoadBalancerBackendAddressPoolListResultPager provides iteration over LoadBalancerBackendAddressPoolListResult pages.
type LoadBalancerBackendAddressPoolListResultPager interface {
	azcore.Pager

	// PageResponse returns the current LoadBalancerBackendAddressPoolListResultResponse.
	PageResponse() LoadBalancerBackendAddressPoolListResultResponse
}

type loadBalancerBackendAddressPoolListResultCreateRequest func(context.Context) (*azcore.Request, error)

type loadBalancerBackendAddressPoolListResultHandleError func(*azcore.Response) error

type loadBalancerBackendAddressPoolListResultHandleResponse func(*azcore.Response) (LoadBalancerBackendAddressPoolListResultResponse, error)

type loadBalancerBackendAddressPoolListResultAdvancePage func(context.Context, LoadBalancerBackendAddressPoolListResultResponse) (*azcore.Request, error)

type loadBalancerBackendAddressPoolListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester loadBalancerBackendAddressPoolListResultCreateRequest
	// callback for handling response errors
	errorer loadBalancerBackendAddressPoolListResultHandleError
	// callback for handling the HTTP response
	responder loadBalancerBackendAddressPoolListResultHandleResponse
	// callback for advancing to the next page
	advancer loadBalancerBackendAddressPoolListResultAdvancePage
	// contains the current response
	current LoadBalancerBackendAddressPoolListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *loadBalancerBackendAddressPoolListResultPager) Err() error {
	return p.err
}

func (p *loadBalancerBackendAddressPoolListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.LoadBalancerBackendAddressPoolListResult.NextLink == nil || len(*p.current.LoadBalancerBackendAddressPoolListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *loadBalancerBackendAddressPoolListResultPager) PageResponse() LoadBalancerBackendAddressPoolListResultResponse {
	return p.current
}

// LoadBalancerFrontendIPConfigurationListResultPager provides iteration over LoadBalancerFrontendIPConfigurationListResult pages.
type LoadBalancerFrontendIPConfigurationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current LoadBalancerFrontendIPConfigurationListResultResponse.
	PageResponse() LoadBalancerFrontendIPConfigurationListResultResponse
}

type loadBalancerFrontendIPConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type loadBalancerFrontendIPConfigurationListResultHandleError func(*azcore.Response) error

type loadBalancerFrontendIPConfigurationListResultHandleResponse func(*azcore.Response) (LoadBalancerFrontendIPConfigurationListResultResponse, error)

type loadBalancerFrontendIPConfigurationListResultAdvancePage func(context.Context, LoadBalancerFrontendIPConfigurationListResultResponse) (*azcore.Request, error)

type loadBalancerFrontendIPConfigurationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester loadBalancerFrontendIPConfigurationListResultCreateRequest
	// callback for handling response errors
	errorer loadBalancerFrontendIPConfigurationListResultHandleError
	// callback for handling the HTTP response
	responder loadBalancerFrontendIPConfigurationListResultHandleResponse
	// callback for advancing to the next page
	advancer loadBalancerFrontendIPConfigurationListResultAdvancePage
	// contains the current response
	current LoadBalancerFrontendIPConfigurationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *loadBalancerFrontendIPConfigurationListResultPager) Err() error {
	return p.err
}

func (p *loadBalancerFrontendIPConfigurationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.LoadBalancerFrontendIPConfigurationListResult.NextLink == nil || len(*p.current.LoadBalancerFrontendIPConfigurationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *loadBalancerFrontendIPConfigurationListResultPager) PageResponse() LoadBalancerFrontendIPConfigurationListResultResponse {
	return p.current
}

// LoadBalancerListResultPager provides iteration over LoadBalancerListResult pages.
type LoadBalancerListResultPager interface {
	azcore.Pager

	// PageResponse returns the current LoadBalancerListResultResponse.
	PageResponse() LoadBalancerListResultResponse
}

type loadBalancerListResultCreateRequest func(context.Context) (*azcore.Request, error)

type loadBalancerListResultHandleError func(*azcore.Response) error

type loadBalancerListResultHandleResponse func(*azcore.Response) (LoadBalancerListResultResponse, error)

type loadBalancerListResultAdvancePage func(context.Context, LoadBalancerListResultResponse) (*azcore.Request, error)

type loadBalancerListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester loadBalancerListResultCreateRequest
	// callback for handling response errors
	errorer loadBalancerListResultHandleError
	// callback for handling the HTTP response
	responder loadBalancerListResultHandleResponse
	// callback for advancing to the next page
	advancer loadBalancerListResultAdvancePage
	// contains the current response
	current LoadBalancerListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *loadBalancerListResultPager) Err() error {
	return p.err
}

func (p *loadBalancerListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.LoadBalancerListResult.NextLink == nil || len(*p.current.LoadBalancerListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *loadBalancerListResultPager) PageResponse() LoadBalancerListResultResponse {
	return p.current
}

// LoadBalancerLoadBalancingRuleListResultPager provides iteration over LoadBalancerLoadBalancingRuleListResult pages.
type LoadBalancerLoadBalancingRuleListResultPager interface {
	azcore.Pager

	// PageResponse returns the current LoadBalancerLoadBalancingRuleListResultResponse.
	PageResponse() LoadBalancerLoadBalancingRuleListResultResponse
}

type loadBalancerLoadBalancingRuleListResultCreateRequest func(context.Context) (*azcore.Request, error)

type loadBalancerLoadBalancingRuleListResultHandleError func(*azcore.Response) error

type loadBalancerLoadBalancingRuleListResultHandleResponse func(*azcore.Response) (LoadBalancerLoadBalancingRuleListResultResponse, error)

type loadBalancerLoadBalancingRuleListResultAdvancePage func(context.Context, LoadBalancerLoadBalancingRuleListResultResponse) (*azcore.Request, error)

type loadBalancerLoadBalancingRuleListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester loadBalancerLoadBalancingRuleListResultCreateRequest
	// callback for handling response errors
	errorer loadBalancerLoadBalancingRuleListResultHandleError
	// callback for handling the HTTP response
	responder loadBalancerLoadBalancingRuleListResultHandleResponse
	// callback for advancing to the next page
	advancer loadBalancerLoadBalancingRuleListResultAdvancePage
	// contains the current response
	current LoadBalancerLoadBalancingRuleListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *loadBalancerLoadBalancingRuleListResultPager) Err() error {
	return p.err
}

func (p *loadBalancerLoadBalancingRuleListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.LoadBalancerLoadBalancingRuleListResult.NextLink == nil || len(*p.current.LoadBalancerLoadBalancingRuleListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *loadBalancerLoadBalancingRuleListResultPager) PageResponse() LoadBalancerLoadBalancingRuleListResultResponse {
	return p.current
}

// LoadBalancerOutboundRuleListResultPager provides iteration over LoadBalancerOutboundRuleListResult pages.
type LoadBalancerOutboundRuleListResultPager interface {
	azcore.Pager

	// PageResponse returns the current LoadBalancerOutboundRuleListResultResponse.
	PageResponse() LoadBalancerOutboundRuleListResultResponse
}

type loadBalancerOutboundRuleListResultCreateRequest func(context.Context) (*azcore.Request, error)

type loadBalancerOutboundRuleListResultHandleError func(*azcore.Response) error

type loadBalancerOutboundRuleListResultHandleResponse func(*azcore.Response) (LoadBalancerOutboundRuleListResultResponse, error)

type loadBalancerOutboundRuleListResultAdvancePage func(context.Context, LoadBalancerOutboundRuleListResultResponse) (*azcore.Request, error)

type loadBalancerOutboundRuleListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester loadBalancerOutboundRuleListResultCreateRequest
	// callback for handling response errors
	errorer loadBalancerOutboundRuleListResultHandleError
	// callback for handling the HTTP response
	responder loadBalancerOutboundRuleListResultHandleResponse
	// callback for advancing to the next page
	advancer loadBalancerOutboundRuleListResultAdvancePage
	// contains the current response
	current LoadBalancerOutboundRuleListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *loadBalancerOutboundRuleListResultPager) Err() error {
	return p.err
}

func (p *loadBalancerOutboundRuleListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.LoadBalancerOutboundRuleListResult.NextLink == nil || len(*p.current.LoadBalancerOutboundRuleListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *loadBalancerOutboundRuleListResultPager) PageResponse() LoadBalancerOutboundRuleListResultResponse {
	return p.current
}

// LoadBalancerProbeListResultPager provides iteration over LoadBalancerProbeListResult pages.
type LoadBalancerProbeListResultPager interface {
	azcore.Pager

	// PageResponse returns the current LoadBalancerProbeListResultResponse.
	PageResponse() LoadBalancerProbeListResultResponse
}

type loadBalancerProbeListResultCreateRequest func(context.Context) (*azcore.Request, error)

type loadBalancerProbeListResultHandleError func(*azcore.Response) error

type loadBalancerProbeListResultHandleResponse func(*azcore.Response) (LoadBalancerProbeListResultResponse, error)

type loadBalancerProbeListResultAdvancePage func(context.Context, LoadBalancerProbeListResultResponse) (*azcore.Request, error)

type loadBalancerProbeListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester loadBalancerProbeListResultCreateRequest
	// callback for handling response errors
	errorer loadBalancerProbeListResultHandleError
	// callback for handling the HTTP response
	responder loadBalancerProbeListResultHandleResponse
	// callback for advancing to the next page
	advancer loadBalancerProbeListResultAdvancePage
	// contains the current response
	current LoadBalancerProbeListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *loadBalancerProbeListResultPager) Err() error {
	return p.err
}

func (p *loadBalancerProbeListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.LoadBalancerProbeListResult.NextLink == nil || len(*p.current.LoadBalancerProbeListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *loadBalancerProbeListResultPager) PageResponse() LoadBalancerProbeListResultResponse {
	return p.current
}

// LocalNetworkGatewayListResultPager provides iteration over LocalNetworkGatewayListResult pages.
type LocalNetworkGatewayListResultPager interface {
	azcore.Pager

	// PageResponse returns the current LocalNetworkGatewayListResultResponse.
	PageResponse() LocalNetworkGatewayListResultResponse
}

type localNetworkGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error)

type localNetworkGatewayListResultHandleError func(*azcore.Response) error

type localNetworkGatewayListResultHandleResponse func(*azcore.Response) (LocalNetworkGatewayListResultResponse, error)

type localNetworkGatewayListResultAdvancePage func(context.Context, LocalNetworkGatewayListResultResponse) (*azcore.Request, error)

type localNetworkGatewayListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester localNetworkGatewayListResultCreateRequest
	// callback for handling response errors
	errorer localNetworkGatewayListResultHandleError
	// callback for handling the HTTP response
	responder localNetworkGatewayListResultHandleResponse
	// callback for advancing to the next page
	advancer localNetworkGatewayListResultAdvancePage
	// contains the current response
	current LocalNetworkGatewayListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *localNetworkGatewayListResultPager) Err() error {
	return p.err
}

func (p *localNetworkGatewayListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.LocalNetworkGatewayListResult.NextLink == nil || len(*p.current.LocalNetworkGatewayListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *localNetworkGatewayListResultPager) PageResponse() LocalNetworkGatewayListResultResponse {
	return p.current
}

// NatGatewayListResultPager provides iteration over NatGatewayListResult pages.
type NatGatewayListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NatGatewayListResultResponse.
	PageResponse() NatGatewayListResultResponse
}

type natGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error)

type natGatewayListResultHandleError func(*azcore.Response) error

type natGatewayListResultHandleResponse func(*azcore.Response) (NatGatewayListResultResponse, error)

type natGatewayListResultAdvancePage func(context.Context, NatGatewayListResultResponse) (*azcore.Request, error)

type natGatewayListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester natGatewayListResultCreateRequest
	// callback for handling response errors
	errorer natGatewayListResultHandleError
	// callback for handling the HTTP response
	responder natGatewayListResultHandleResponse
	// callback for advancing to the next page
	advancer natGatewayListResultAdvancePage
	// contains the current response
	current NatGatewayListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *natGatewayListResultPager) Err() error {
	return p.err
}

func (p *natGatewayListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NatGatewayListResult.NextLink == nil || len(*p.current.NatGatewayListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *natGatewayListResultPager) PageResponse() NatGatewayListResultResponse {
	return p.current
}

// NetworkInterfaceIPConfigurationListResultPager provides iteration over NetworkInterfaceIPConfigurationListResult pages.
type NetworkInterfaceIPConfigurationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkInterfaceIPConfigurationListResultResponse.
	PageResponse() NetworkInterfaceIPConfigurationListResultResponse
}

type networkInterfaceIPConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkInterfaceIPConfigurationListResultHandleError func(*azcore.Response) error

type networkInterfaceIPConfigurationListResultHandleResponse func(*azcore.Response) (NetworkInterfaceIPConfigurationListResultResponse, error)

type networkInterfaceIPConfigurationListResultAdvancePage func(context.Context, NetworkInterfaceIPConfigurationListResultResponse) (*azcore.Request, error)

type networkInterfaceIPConfigurationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkInterfaceIPConfigurationListResultCreateRequest
	// callback for handling response errors
	errorer networkInterfaceIPConfigurationListResultHandleError
	// callback for handling the HTTP response
	responder networkInterfaceIPConfigurationListResultHandleResponse
	// callback for advancing to the next page
	advancer networkInterfaceIPConfigurationListResultAdvancePage
	// contains the current response
	current NetworkInterfaceIPConfigurationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkInterfaceIPConfigurationListResultPager) Err() error {
	return p.err
}

func (p *networkInterfaceIPConfigurationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkInterfaceIPConfigurationListResult.NextLink == nil || len(*p.current.NetworkInterfaceIPConfigurationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkInterfaceIPConfigurationListResultPager) PageResponse() NetworkInterfaceIPConfigurationListResultResponse {
	return p.current
}

// NetworkInterfaceListResultPager provides iteration over NetworkInterfaceListResult pages.
type NetworkInterfaceListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkInterfaceListResultResponse.
	PageResponse() NetworkInterfaceListResultResponse
}

type networkInterfaceListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkInterfaceListResultHandleError func(*azcore.Response) error

type networkInterfaceListResultHandleResponse func(*azcore.Response) (NetworkInterfaceListResultResponse, error)

type networkInterfaceListResultAdvancePage func(context.Context, NetworkInterfaceListResultResponse) (*azcore.Request, error)

type networkInterfaceListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkInterfaceListResultCreateRequest
	// callback for handling response errors
	errorer networkInterfaceListResultHandleError
	// callback for handling the HTTP response
	responder networkInterfaceListResultHandleResponse
	// callback for advancing to the next page
	advancer networkInterfaceListResultAdvancePage
	// contains the current response
	current NetworkInterfaceListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkInterfaceListResultPager) Err() error {
	return p.err
}

func (p *networkInterfaceListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkInterfaceListResult.NextLink == nil || len(*p.current.NetworkInterfaceListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkInterfaceListResultPager) PageResponse() NetworkInterfaceListResultResponse {
	return p.current
}

// NetworkInterfaceLoadBalancerListResultPager provides iteration over NetworkInterfaceLoadBalancerListResult pages.
type NetworkInterfaceLoadBalancerListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkInterfaceLoadBalancerListResultResponse.
	PageResponse() NetworkInterfaceLoadBalancerListResultResponse
}

type networkInterfaceLoadBalancerListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkInterfaceLoadBalancerListResultHandleError func(*azcore.Response) error

type networkInterfaceLoadBalancerListResultHandleResponse func(*azcore.Response) (NetworkInterfaceLoadBalancerListResultResponse, error)

type networkInterfaceLoadBalancerListResultAdvancePage func(context.Context, NetworkInterfaceLoadBalancerListResultResponse) (*azcore.Request, error)

type networkInterfaceLoadBalancerListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkInterfaceLoadBalancerListResultCreateRequest
	// callback for handling response errors
	errorer networkInterfaceLoadBalancerListResultHandleError
	// callback for handling the HTTP response
	responder networkInterfaceLoadBalancerListResultHandleResponse
	// callback for advancing to the next page
	advancer networkInterfaceLoadBalancerListResultAdvancePage
	// contains the current response
	current NetworkInterfaceLoadBalancerListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkInterfaceLoadBalancerListResultPager) Err() error {
	return p.err
}

func (p *networkInterfaceLoadBalancerListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkInterfaceLoadBalancerListResult.NextLink == nil || len(*p.current.NetworkInterfaceLoadBalancerListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkInterfaceLoadBalancerListResultPager) PageResponse() NetworkInterfaceLoadBalancerListResultResponse {
	return p.current
}

// NetworkInterfaceTapConfigurationListResultPager provides iteration over NetworkInterfaceTapConfigurationListResult pages.
type NetworkInterfaceTapConfigurationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkInterfaceTapConfigurationListResultResponse.
	PageResponse() NetworkInterfaceTapConfigurationListResultResponse
}

type networkInterfaceTapConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkInterfaceTapConfigurationListResultHandleError func(*azcore.Response) error

type networkInterfaceTapConfigurationListResultHandleResponse func(*azcore.Response) (NetworkInterfaceTapConfigurationListResultResponse, error)

type networkInterfaceTapConfigurationListResultAdvancePage func(context.Context, NetworkInterfaceTapConfigurationListResultResponse) (*azcore.Request, error)

type networkInterfaceTapConfigurationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkInterfaceTapConfigurationListResultCreateRequest
	// callback for handling response errors
	errorer networkInterfaceTapConfigurationListResultHandleError
	// callback for handling the HTTP response
	responder networkInterfaceTapConfigurationListResultHandleResponse
	// callback for advancing to the next page
	advancer networkInterfaceTapConfigurationListResultAdvancePage
	// contains the current response
	current NetworkInterfaceTapConfigurationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkInterfaceTapConfigurationListResultPager) Err() error {
	return p.err
}

func (p *networkInterfaceTapConfigurationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkInterfaceTapConfigurationListResult.NextLink == nil || len(*p.current.NetworkInterfaceTapConfigurationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkInterfaceTapConfigurationListResultPager) PageResponse() NetworkInterfaceTapConfigurationListResultResponse {
	return p.current
}

// NetworkProfileListResultPager provides iteration over NetworkProfileListResult pages.
type NetworkProfileListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkProfileListResultResponse.
	PageResponse() NetworkProfileListResultResponse
}

type networkProfileListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkProfileListResultHandleError func(*azcore.Response) error

type networkProfileListResultHandleResponse func(*azcore.Response) (NetworkProfileListResultResponse, error)

type networkProfileListResultAdvancePage func(context.Context, NetworkProfileListResultResponse) (*azcore.Request, error)

type networkProfileListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkProfileListResultCreateRequest
	// callback for handling response errors
	errorer networkProfileListResultHandleError
	// callback for handling the HTTP response
	responder networkProfileListResultHandleResponse
	// callback for advancing to the next page
	advancer networkProfileListResultAdvancePage
	// contains the current response
	current NetworkProfileListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkProfileListResultPager) Err() error {
	return p.err
}

func (p *networkProfileListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkProfileListResult.NextLink == nil || len(*p.current.NetworkProfileListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkProfileListResultPager) PageResponse() NetworkProfileListResultResponse {
	return p.current
}

// NetworkSecurityGroupListResultPager provides iteration over NetworkSecurityGroupListResult pages.
type NetworkSecurityGroupListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkSecurityGroupListResultResponse.
	PageResponse() NetworkSecurityGroupListResultResponse
}

type networkSecurityGroupListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkSecurityGroupListResultHandleError func(*azcore.Response) error

type networkSecurityGroupListResultHandleResponse func(*azcore.Response) (NetworkSecurityGroupListResultResponse, error)

type networkSecurityGroupListResultAdvancePage func(context.Context, NetworkSecurityGroupListResultResponse) (*azcore.Request, error)

type networkSecurityGroupListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkSecurityGroupListResultCreateRequest
	// callback for handling response errors
	errorer networkSecurityGroupListResultHandleError
	// callback for handling the HTTP response
	responder networkSecurityGroupListResultHandleResponse
	// callback for advancing to the next page
	advancer networkSecurityGroupListResultAdvancePage
	// contains the current response
	current NetworkSecurityGroupListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkSecurityGroupListResultPager) Err() error {
	return p.err
}

func (p *networkSecurityGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkSecurityGroupListResult.NextLink == nil || len(*p.current.NetworkSecurityGroupListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkSecurityGroupListResultPager) PageResponse() NetworkSecurityGroupListResultResponse {
	return p.current
}

// NetworkVirtualApplianceListResultPager provides iteration over NetworkVirtualApplianceListResult pages.
type NetworkVirtualApplianceListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkVirtualApplianceListResultResponse.
	PageResponse() NetworkVirtualApplianceListResultResponse
}

type networkVirtualApplianceListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkVirtualApplianceListResultHandleError func(*azcore.Response) error

type networkVirtualApplianceListResultHandleResponse func(*azcore.Response) (NetworkVirtualApplianceListResultResponse, error)

type networkVirtualApplianceListResultAdvancePage func(context.Context, NetworkVirtualApplianceListResultResponse) (*azcore.Request, error)

type networkVirtualApplianceListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkVirtualApplianceListResultCreateRequest
	// callback for handling response errors
	errorer networkVirtualApplianceListResultHandleError
	// callback for handling the HTTP response
	responder networkVirtualApplianceListResultHandleResponse
	// callback for advancing to the next page
	advancer networkVirtualApplianceListResultAdvancePage
	// contains the current response
	current NetworkVirtualApplianceListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkVirtualApplianceListResultPager) Err() error {
	return p.err
}

func (p *networkVirtualApplianceListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkVirtualApplianceListResult.NextLink == nil || len(*p.current.NetworkVirtualApplianceListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkVirtualApplianceListResultPager) PageResponse() NetworkVirtualApplianceListResultResponse {
	return p.current
}

// NetworkVirtualApplianceSKUListResultPager provides iteration over NetworkVirtualApplianceSKUListResult pages.
type NetworkVirtualApplianceSKUListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkVirtualApplianceSKUListResultResponse.
	PageResponse() NetworkVirtualApplianceSKUListResultResponse
}

type networkVirtualApplianceSKUListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkVirtualApplianceSKUListResultHandleError func(*azcore.Response) error

type networkVirtualApplianceSKUListResultHandleResponse func(*azcore.Response) (NetworkVirtualApplianceSKUListResultResponse, error)

type networkVirtualApplianceSKUListResultAdvancePage func(context.Context, NetworkVirtualApplianceSKUListResultResponse) (*azcore.Request, error)

type networkVirtualApplianceSKUListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkVirtualApplianceSKUListResultCreateRequest
	// callback for handling response errors
	errorer networkVirtualApplianceSKUListResultHandleError
	// callback for handling the HTTP response
	responder networkVirtualApplianceSKUListResultHandleResponse
	// callback for advancing to the next page
	advancer networkVirtualApplianceSKUListResultAdvancePage
	// contains the current response
	current NetworkVirtualApplianceSKUListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkVirtualApplianceSKUListResultPager) Err() error {
	return p.err
}

func (p *networkVirtualApplianceSKUListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkVirtualApplianceSKUListResult.NextLink == nil || len(*p.current.NetworkVirtualApplianceSKUListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkVirtualApplianceSKUListResultPager) PageResponse() NetworkVirtualApplianceSKUListResultResponse {
	return p.current
}

// NetworkVirtualApplianceSiteListResultPager provides iteration over NetworkVirtualApplianceSiteListResult pages.
type NetworkVirtualApplianceSiteListResultPager interface {
	azcore.Pager

	// PageResponse returns the current NetworkVirtualApplianceSiteListResultResponse.
	PageResponse() NetworkVirtualApplianceSiteListResultResponse
}

type networkVirtualApplianceSiteListResultCreateRequest func(context.Context) (*azcore.Request, error)

type networkVirtualApplianceSiteListResultHandleError func(*azcore.Response) error

type networkVirtualApplianceSiteListResultHandleResponse func(*azcore.Response) (NetworkVirtualApplianceSiteListResultResponse, error)

type networkVirtualApplianceSiteListResultAdvancePage func(context.Context, NetworkVirtualApplianceSiteListResultResponse) (*azcore.Request, error)

type networkVirtualApplianceSiteListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester networkVirtualApplianceSiteListResultCreateRequest
	// callback for handling response errors
	errorer networkVirtualApplianceSiteListResultHandleError
	// callback for handling the HTTP response
	responder networkVirtualApplianceSiteListResultHandleResponse
	// callback for advancing to the next page
	advancer networkVirtualApplianceSiteListResultAdvancePage
	// contains the current response
	current NetworkVirtualApplianceSiteListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *networkVirtualApplianceSiteListResultPager) Err() error {
	return p.err
}

func (p *networkVirtualApplianceSiteListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.NetworkVirtualApplianceSiteListResult.NextLink == nil || len(*p.current.NetworkVirtualApplianceSiteListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *networkVirtualApplianceSiteListResultPager) PageResponse() NetworkVirtualApplianceSiteListResultResponse {
	return p.current
}

// OperationListResultPager provides iteration over OperationListResult pages.
type OperationListResultPager interface {
	azcore.Pager

	// PageResponse returns the current OperationListResultResponse.
	PageResponse() OperationListResultResponse
}

type operationListResultCreateRequest func(context.Context) (*azcore.Request, error)

type operationListResultHandleError func(*azcore.Response) error

type operationListResultHandleResponse func(*azcore.Response) (OperationListResultResponse, error)

type operationListResultAdvancePage func(context.Context, OperationListResultResponse) (*azcore.Request, error)

type operationListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester operationListResultCreateRequest
	// callback for handling response errors
	errorer operationListResultHandleError
	// callback for handling the HTTP response
	responder operationListResultHandleResponse
	// callback for advancing to the next page
	advancer operationListResultAdvancePage
	// contains the current response
	current OperationListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *operationListResultPager) Err() error {
	return p.err
}

func (p *operationListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.OperationListResult.NextLink == nil || len(*p.current.OperationListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *operationListResultPager) PageResponse() OperationListResultResponse {
	return p.current
}

// PeerExpressRouteCircuitConnectionListResultPager provides iteration over PeerExpressRouteCircuitConnectionListResult pages.
type PeerExpressRouteCircuitConnectionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current PeerExpressRouteCircuitConnectionListResultResponse.
	PageResponse() PeerExpressRouteCircuitConnectionListResultResponse
}

type peerExpressRouteCircuitConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type peerExpressRouteCircuitConnectionListResultHandleError func(*azcore.Response) error

type peerExpressRouteCircuitConnectionListResultHandleResponse func(*azcore.Response) (PeerExpressRouteCircuitConnectionListResultResponse, error)

type peerExpressRouteCircuitConnectionListResultAdvancePage func(context.Context, PeerExpressRouteCircuitConnectionListResultResponse) (*azcore.Request, error)

type peerExpressRouteCircuitConnectionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester peerExpressRouteCircuitConnectionListResultCreateRequest
	// callback for handling response errors
	errorer peerExpressRouteCircuitConnectionListResultHandleError
	// callback for handling the HTTP response
	responder peerExpressRouteCircuitConnectionListResultHandleResponse
	// callback for advancing to the next page
	advancer peerExpressRouteCircuitConnectionListResultAdvancePage
	// contains the current response
	current PeerExpressRouteCircuitConnectionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *peerExpressRouteCircuitConnectionListResultPager) Err() error {
	return p.err
}

func (p *peerExpressRouteCircuitConnectionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.PeerExpressRouteCircuitConnectionListResult.NextLink == nil || len(*p.current.PeerExpressRouteCircuitConnectionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *peerExpressRouteCircuitConnectionListResultPager) PageResponse() PeerExpressRouteCircuitConnectionListResultResponse {
	return p.current
}

// PrivateDNSZoneGroupListResultPager provides iteration over PrivateDNSZoneGroupListResult pages.
type PrivateDNSZoneGroupListResultPager interface {
	azcore.Pager

	// PageResponse returns the current PrivateDNSZoneGroupListResultResponse.
	PageResponse() PrivateDNSZoneGroupListResultResponse
}

type privateDNSZoneGroupListResultCreateRequest func(context.Context) (*azcore.Request, error)

type privateDNSZoneGroupListResultHandleError func(*azcore.Response) error

type privateDNSZoneGroupListResultHandleResponse func(*azcore.Response) (PrivateDNSZoneGroupListResultResponse, error)

type privateDNSZoneGroupListResultAdvancePage func(context.Context, PrivateDNSZoneGroupListResultResponse) (*azcore.Request, error)

type privateDNSZoneGroupListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester privateDNSZoneGroupListResultCreateRequest
	// callback for handling response errors
	errorer privateDNSZoneGroupListResultHandleError
	// callback for handling the HTTP response
	responder privateDNSZoneGroupListResultHandleResponse
	// callback for advancing to the next page
	advancer privateDNSZoneGroupListResultAdvancePage
	// contains the current response
	current PrivateDNSZoneGroupListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *privateDNSZoneGroupListResultPager) Err() error {
	return p.err
}

func (p *privateDNSZoneGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.PrivateDNSZoneGroupListResult.NextLink == nil || len(*p.current.PrivateDNSZoneGroupListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *privateDNSZoneGroupListResultPager) PageResponse() PrivateDNSZoneGroupListResultResponse {
	return p.current
}

// PrivateEndpointConnectionListResultPager provides iteration over PrivateEndpointConnectionListResult pages.
type PrivateEndpointConnectionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current PrivateEndpointConnectionListResultResponse.
	PageResponse() PrivateEndpointConnectionListResultResponse
}

type privateEndpointConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type privateEndpointConnectionListResultHandleError func(*azcore.Response) error

type privateEndpointConnectionListResultHandleResponse func(*azcore.Response) (PrivateEndpointConnectionListResultResponse, error)

type privateEndpointConnectionListResultAdvancePage func(context.Context, PrivateEndpointConnectionListResultResponse) (*azcore.Request, error)

type privateEndpointConnectionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester privateEndpointConnectionListResultCreateRequest
	// callback for handling response errors
	errorer privateEndpointConnectionListResultHandleError
	// callback for handling the HTTP response
	responder privateEndpointConnectionListResultHandleResponse
	// callback for advancing to the next page
	advancer privateEndpointConnectionListResultAdvancePage
	// contains the current response
	current PrivateEndpointConnectionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *privateEndpointConnectionListResultPager) Err() error {
	return p.err
}

func (p *privateEndpointConnectionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.PrivateEndpointConnectionListResult.NextLink == nil || len(*p.current.PrivateEndpointConnectionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *privateEndpointConnectionListResultPager) PageResponse() PrivateEndpointConnectionListResultResponse {
	return p.current
}

// PrivateEndpointListResultPager provides iteration over PrivateEndpointListResult pages.
type PrivateEndpointListResultPager interface {
	azcore.Pager

	// PageResponse returns the current PrivateEndpointListResultResponse.
	PageResponse() PrivateEndpointListResultResponse
}

type privateEndpointListResultCreateRequest func(context.Context) (*azcore.Request, error)

type privateEndpointListResultHandleError func(*azcore.Response) error

type privateEndpointListResultHandleResponse func(*azcore.Response) (PrivateEndpointListResultResponse, error)

type privateEndpointListResultAdvancePage func(context.Context, PrivateEndpointListResultResponse) (*azcore.Request, error)

type privateEndpointListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester privateEndpointListResultCreateRequest
	// callback for handling response errors
	errorer privateEndpointListResultHandleError
	// callback for handling the HTTP response
	responder privateEndpointListResultHandleResponse
	// callback for advancing to the next page
	advancer privateEndpointListResultAdvancePage
	// contains the current response
	current PrivateEndpointListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *privateEndpointListResultPager) Err() error {
	return p.err
}

func (p *privateEndpointListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.PrivateEndpointListResult.NextLink == nil || len(*p.current.PrivateEndpointListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *privateEndpointListResultPager) PageResponse() PrivateEndpointListResultResponse {
	return p.current
}

// PrivateLinkServiceListResultPager provides iteration over PrivateLinkServiceListResult pages.
type PrivateLinkServiceListResultPager interface {
	azcore.Pager

	// PageResponse returns the current PrivateLinkServiceListResultResponse.
	PageResponse() PrivateLinkServiceListResultResponse
}

type privateLinkServiceListResultCreateRequest func(context.Context) (*azcore.Request, error)

type privateLinkServiceListResultHandleError func(*azcore.Response) error

type privateLinkServiceListResultHandleResponse func(*azcore.Response) (PrivateLinkServiceListResultResponse, error)

type privateLinkServiceListResultAdvancePage func(context.Context, PrivateLinkServiceListResultResponse) (*azcore.Request, error)

type privateLinkServiceListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester privateLinkServiceListResultCreateRequest
	// callback for handling response errors
	errorer privateLinkServiceListResultHandleError
	// callback for handling the HTTP response
	responder privateLinkServiceListResultHandleResponse
	// callback for advancing to the next page
	advancer privateLinkServiceListResultAdvancePage
	// contains the current response
	current PrivateLinkServiceListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *privateLinkServiceListResultPager) Err() error {
	return p.err
}

func (p *privateLinkServiceListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.PrivateLinkServiceListResult.NextLink == nil || len(*p.current.PrivateLinkServiceListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *privateLinkServiceListResultPager) PageResponse() PrivateLinkServiceListResultResponse {
	return p.current
}

// PublicIPAddressListResultPager provides iteration over PublicIPAddressListResult pages.
type PublicIPAddressListResultPager interface {
	azcore.Pager

	// PageResponse returns the current PublicIPAddressListResultResponse.
	PageResponse() PublicIPAddressListResultResponse
}

type publicIPAddressListResultCreateRequest func(context.Context) (*azcore.Request, error)

type publicIPAddressListResultHandleError func(*azcore.Response) error

type publicIPAddressListResultHandleResponse func(*azcore.Response) (PublicIPAddressListResultResponse, error)

type publicIPAddressListResultAdvancePage func(context.Context, PublicIPAddressListResultResponse) (*azcore.Request, error)

type publicIPAddressListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester publicIPAddressListResultCreateRequest
	// callback for handling response errors
	errorer publicIPAddressListResultHandleError
	// callback for handling the HTTP response
	responder publicIPAddressListResultHandleResponse
	// callback for advancing to the next page
	advancer publicIPAddressListResultAdvancePage
	// contains the current response
	current PublicIPAddressListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *publicIPAddressListResultPager) Err() error {
	return p.err
}

func (p *publicIPAddressListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.PublicIPAddressListResult.NextLink == nil || len(*p.current.PublicIPAddressListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *publicIPAddressListResultPager) PageResponse() PublicIPAddressListResultResponse {
	return p.current
}

// PublicIPPrefixListResultPager provides iteration over PublicIPPrefixListResult pages.
type PublicIPPrefixListResultPager interface {
	azcore.Pager

	// PageResponse returns the current PublicIPPrefixListResultResponse.
	PageResponse() PublicIPPrefixListResultResponse
}

type publicIPPrefixListResultCreateRequest func(context.Context) (*azcore.Request, error)

type publicIPPrefixListResultHandleError func(*azcore.Response) error

type publicIPPrefixListResultHandleResponse func(*azcore.Response) (PublicIPPrefixListResultResponse, error)

type publicIPPrefixListResultAdvancePage func(context.Context, PublicIPPrefixListResultResponse) (*azcore.Request, error)

type publicIPPrefixListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester publicIPPrefixListResultCreateRequest
	// callback for handling response errors
	errorer publicIPPrefixListResultHandleError
	// callback for handling the HTTP response
	responder publicIPPrefixListResultHandleResponse
	// callback for advancing to the next page
	advancer publicIPPrefixListResultAdvancePage
	// contains the current response
	current PublicIPPrefixListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *publicIPPrefixListResultPager) Err() error {
	return p.err
}

func (p *publicIPPrefixListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.PublicIPPrefixListResult.NextLink == nil || len(*p.current.PublicIPPrefixListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *publicIPPrefixListResultPager) PageResponse() PublicIPPrefixListResultResponse {
	return p.current
}

// RouteFilterListResultPager provides iteration over RouteFilterListResult pages.
type RouteFilterListResultPager interface {
	azcore.Pager

	// PageResponse returns the current RouteFilterListResultResponse.
	PageResponse() RouteFilterListResultResponse
}

type routeFilterListResultCreateRequest func(context.Context) (*azcore.Request, error)

type routeFilterListResultHandleError func(*azcore.Response) error

type routeFilterListResultHandleResponse func(*azcore.Response) (RouteFilterListResultResponse, error)

type routeFilterListResultAdvancePage func(context.Context, RouteFilterListResultResponse) (*azcore.Request, error)

type routeFilterListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester routeFilterListResultCreateRequest
	// callback for handling response errors
	errorer routeFilterListResultHandleError
	// callback for handling the HTTP response
	responder routeFilterListResultHandleResponse
	// callback for advancing to the next page
	advancer routeFilterListResultAdvancePage
	// contains the current response
	current RouteFilterListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *routeFilterListResultPager) Err() error {
	return p.err
}

func (p *routeFilterListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.RouteFilterListResult.NextLink == nil || len(*p.current.RouteFilterListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *routeFilterListResultPager) PageResponse() RouteFilterListResultResponse {
	return p.current
}

// RouteFilterRuleListResultPager provides iteration over RouteFilterRuleListResult pages.
type RouteFilterRuleListResultPager interface {
	azcore.Pager

	// PageResponse returns the current RouteFilterRuleListResultResponse.
	PageResponse() RouteFilterRuleListResultResponse
}

type routeFilterRuleListResultCreateRequest func(context.Context) (*azcore.Request, error)

type routeFilterRuleListResultHandleError func(*azcore.Response) error

type routeFilterRuleListResultHandleResponse func(*azcore.Response) (RouteFilterRuleListResultResponse, error)

type routeFilterRuleListResultAdvancePage func(context.Context, RouteFilterRuleListResultResponse) (*azcore.Request, error)

type routeFilterRuleListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester routeFilterRuleListResultCreateRequest
	// callback for handling response errors
	errorer routeFilterRuleListResultHandleError
	// callback for handling the HTTP response
	responder routeFilterRuleListResultHandleResponse
	// callback for advancing to the next page
	advancer routeFilterRuleListResultAdvancePage
	// contains the current response
	current RouteFilterRuleListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *routeFilterRuleListResultPager) Err() error {
	return p.err
}

func (p *routeFilterRuleListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.RouteFilterRuleListResult.NextLink == nil || len(*p.current.RouteFilterRuleListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *routeFilterRuleListResultPager) PageResponse() RouteFilterRuleListResultResponse {
	return p.current
}

// RouteListResultPager provides iteration over RouteListResult pages.
type RouteListResultPager interface {
	azcore.Pager

	// PageResponse returns the current RouteListResultResponse.
	PageResponse() RouteListResultResponse
}

type routeListResultCreateRequest func(context.Context) (*azcore.Request, error)

type routeListResultHandleError func(*azcore.Response) error

type routeListResultHandleResponse func(*azcore.Response) (RouteListResultResponse, error)

type routeListResultAdvancePage func(context.Context, RouteListResultResponse) (*azcore.Request, error)

type routeListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester routeListResultCreateRequest
	// callback for handling response errors
	errorer routeListResultHandleError
	// callback for handling the HTTP response
	responder routeListResultHandleResponse
	// callback for advancing to the next page
	advancer routeListResultAdvancePage
	// contains the current response
	current RouteListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *routeListResultPager) Err() error {
	return p.err
}

func (p *routeListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.RouteListResult.NextLink == nil || len(*p.current.RouteListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *routeListResultPager) PageResponse() RouteListResultResponse {
	return p.current
}

// RouteTableListResultPager provides iteration over RouteTableListResult pages.
type RouteTableListResultPager interface {
	azcore.Pager

	// PageResponse returns the current RouteTableListResultResponse.
	PageResponse() RouteTableListResultResponse
}

type routeTableListResultCreateRequest func(context.Context) (*azcore.Request, error)

type routeTableListResultHandleError func(*azcore.Response) error

type routeTableListResultHandleResponse func(*azcore.Response) (RouteTableListResultResponse, error)

type routeTableListResultAdvancePage func(context.Context, RouteTableListResultResponse) (*azcore.Request, error)

type routeTableListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester routeTableListResultCreateRequest
	// callback for handling response errors
	errorer routeTableListResultHandleError
	// callback for handling the HTTP response
	responder routeTableListResultHandleResponse
	// callback for advancing to the next page
	advancer routeTableListResultAdvancePage
	// contains the current response
	current RouteTableListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *routeTableListResultPager) Err() error {
	return p.err
}

func (p *routeTableListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.RouteTableListResult.NextLink == nil || len(*p.current.RouteTableListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *routeTableListResultPager) PageResponse() RouteTableListResultResponse {
	return p.current
}

// SecurityPartnerProviderListResultPager provides iteration over SecurityPartnerProviderListResult pages.
type SecurityPartnerProviderListResultPager interface {
	azcore.Pager

	// PageResponse returns the current SecurityPartnerProviderListResultResponse.
	PageResponse() SecurityPartnerProviderListResultResponse
}

type securityPartnerProviderListResultCreateRequest func(context.Context) (*azcore.Request, error)

type securityPartnerProviderListResultHandleError func(*azcore.Response) error

type securityPartnerProviderListResultHandleResponse func(*azcore.Response) (SecurityPartnerProviderListResultResponse, error)

type securityPartnerProviderListResultAdvancePage func(context.Context, SecurityPartnerProviderListResultResponse) (*azcore.Request, error)

type securityPartnerProviderListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester securityPartnerProviderListResultCreateRequest
	// callback for handling response errors
	errorer securityPartnerProviderListResultHandleError
	// callback for handling the HTTP response
	responder securityPartnerProviderListResultHandleResponse
	// callback for advancing to the next page
	advancer securityPartnerProviderListResultAdvancePage
	// contains the current response
	current SecurityPartnerProviderListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *securityPartnerProviderListResultPager) Err() error {
	return p.err
}

func (p *securityPartnerProviderListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SecurityPartnerProviderListResult.NextLink == nil || len(*p.current.SecurityPartnerProviderListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *securityPartnerProviderListResultPager) PageResponse() SecurityPartnerProviderListResultResponse {
	return p.current
}

// SecurityRuleListResultPager provides iteration over SecurityRuleListResult pages.
type SecurityRuleListResultPager interface {
	azcore.Pager

	// PageResponse returns the current SecurityRuleListResultResponse.
	PageResponse() SecurityRuleListResultResponse
}

type securityRuleListResultCreateRequest func(context.Context) (*azcore.Request, error)

type securityRuleListResultHandleError func(*azcore.Response) error

type securityRuleListResultHandleResponse func(*azcore.Response) (SecurityRuleListResultResponse, error)

type securityRuleListResultAdvancePage func(context.Context, SecurityRuleListResultResponse) (*azcore.Request, error)

type securityRuleListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester securityRuleListResultCreateRequest
	// callback for handling response errors
	errorer securityRuleListResultHandleError
	// callback for handling the HTTP response
	responder securityRuleListResultHandleResponse
	// callback for advancing to the next page
	advancer securityRuleListResultAdvancePage
	// contains the current response
	current SecurityRuleListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *securityRuleListResultPager) Err() error {
	return p.err
}

func (p *securityRuleListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SecurityRuleListResult.NextLink == nil || len(*p.current.SecurityRuleListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *securityRuleListResultPager) PageResponse() SecurityRuleListResultResponse {
	return p.current
}

// ServiceEndpointPolicyDefinitionListResultPager provides iteration over ServiceEndpointPolicyDefinitionListResult pages.
type ServiceEndpointPolicyDefinitionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ServiceEndpointPolicyDefinitionListResultResponse.
	PageResponse() ServiceEndpointPolicyDefinitionListResultResponse
}

type serviceEndpointPolicyDefinitionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type serviceEndpointPolicyDefinitionListResultHandleError func(*azcore.Response) error

type serviceEndpointPolicyDefinitionListResultHandleResponse func(*azcore.Response) (ServiceEndpointPolicyDefinitionListResultResponse, error)

type serviceEndpointPolicyDefinitionListResultAdvancePage func(context.Context, ServiceEndpointPolicyDefinitionListResultResponse) (*azcore.Request, error)

type serviceEndpointPolicyDefinitionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester serviceEndpointPolicyDefinitionListResultCreateRequest
	// callback for handling response errors
	errorer serviceEndpointPolicyDefinitionListResultHandleError
	// callback for handling the HTTP response
	responder serviceEndpointPolicyDefinitionListResultHandleResponse
	// callback for advancing to the next page
	advancer serviceEndpointPolicyDefinitionListResultAdvancePage
	// contains the current response
	current ServiceEndpointPolicyDefinitionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *serviceEndpointPolicyDefinitionListResultPager) Err() error {
	return p.err
}

func (p *serviceEndpointPolicyDefinitionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ServiceEndpointPolicyDefinitionListResult.NextLink == nil || len(*p.current.ServiceEndpointPolicyDefinitionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *serviceEndpointPolicyDefinitionListResultPager) PageResponse() ServiceEndpointPolicyDefinitionListResultResponse {
	return p.current
}

// ServiceEndpointPolicyListResultPager provides iteration over ServiceEndpointPolicyListResult pages.
type ServiceEndpointPolicyListResultPager interface {
	azcore.Pager

	// PageResponse returns the current ServiceEndpointPolicyListResultResponse.
	PageResponse() ServiceEndpointPolicyListResultResponse
}

type serviceEndpointPolicyListResultCreateRequest func(context.Context) (*azcore.Request, error)

type serviceEndpointPolicyListResultHandleError func(*azcore.Response) error

type serviceEndpointPolicyListResultHandleResponse func(*azcore.Response) (ServiceEndpointPolicyListResultResponse, error)

type serviceEndpointPolicyListResultAdvancePage func(context.Context, ServiceEndpointPolicyListResultResponse) (*azcore.Request, error)

type serviceEndpointPolicyListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester serviceEndpointPolicyListResultCreateRequest
	// callback for handling response errors
	errorer serviceEndpointPolicyListResultHandleError
	// callback for handling the HTTP response
	responder serviceEndpointPolicyListResultHandleResponse
	// callback for advancing to the next page
	advancer serviceEndpointPolicyListResultAdvancePage
	// contains the current response
	current ServiceEndpointPolicyListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *serviceEndpointPolicyListResultPager) Err() error {
	return p.err
}

func (p *serviceEndpointPolicyListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ServiceEndpointPolicyListResult.NextLink == nil || len(*p.current.ServiceEndpointPolicyListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *serviceEndpointPolicyListResultPager) PageResponse() ServiceEndpointPolicyListResultResponse {
	return p.current
}

// SubnetListResultPager provides iteration over SubnetListResult pages.
type SubnetListResultPager interface {
	azcore.Pager

	// PageResponse returns the current SubnetListResultResponse.
	PageResponse() SubnetListResultResponse
}

type subnetListResultCreateRequest func(context.Context) (*azcore.Request, error)

type subnetListResultHandleError func(*azcore.Response) error

type subnetListResultHandleResponse func(*azcore.Response) (SubnetListResultResponse, error)

type subnetListResultAdvancePage func(context.Context, SubnetListResultResponse) (*azcore.Request, error)

type subnetListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester subnetListResultCreateRequest
	// callback for handling response errors
	errorer subnetListResultHandleError
	// callback for handling the HTTP response
	responder subnetListResultHandleResponse
	// callback for advancing to the next page
	advancer subnetListResultAdvancePage
	// contains the current response
	current SubnetListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *subnetListResultPager) Err() error {
	return p.err
}

func (p *subnetListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SubnetListResult.NextLink == nil || len(*p.current.SubnetListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *subnetListResultPager) PageResponse() SubnetListResultResponse {
	return p.current
}

// UsagesListResultPager provides iteration over UsagesListResult pages.
type UsagesListResultPager interface {
	azcore.Pager

	// PageResponse returns the current UsagesListResultResponse.
	PageResponse() UsagesListResultResponse
}

type usagesListResultCreateRequest func(context.Context) (*azcore.Request, error)

type usagesListResultHandleError func(*azcore.Response) error

type usagesListResultHandleResponse func(*azcore.Response) (UsagesListResultResponse, error)

type usagesListResultAdvancePage func(context.Context, UsagesListResultResponse) (*azcore.Request, error)

type usagesListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester usagesListResultCreateRequest
	// callback for handling response errors
	errorer usagesListResultHandleError
	// callback for handling the HTTP response
	responder usagesListResultHandleResponse
	// callback for advancing to the next page
	advancer usagesListResultAdvancePage
	// contains the current response
	current UsagesListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *usagesListResultPager) Err() error {
	return p.err
}

func (p *usagesListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.UsagesListResult.NextLink == nil || len(*p.current.UsagesListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *usagesListResultPager) PageResponse() UsagesListResultResponse {
	return p.current
}

// VirtualNetworkGatewayConnectionListResultPager provides iteration over VirtualNetworkGatewayConnectionListResult pages.
type VirtualNetworkGatewayConnectionListResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualNetworkGatewayConnectionListResultResponse.
	PageResponse() VirtualNetworkGatewayConnectionListResultResponse
}

type virtualNetworkGatewayConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualNetworkGatewayConnectionListResultHandleError func(*azcore.Response) error

type virtualNetworkGatewayConnectionListResultHandleResponse func(*azcore.Response) (VirtualNetworkGatewayConnectionListResultResponse, error)

type virtualNetworkGatewayConnectionListResultAdvancePage func(context.Context, VirtualNetworkGatewayConnectionListResultResponse) (*azcore.Request, error)

type virtualNetworkGatewayConnectionListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualNetworkGatewayConnectionListResultCreateRequest
	// callback for handling response errors
	errorer virtualNetworkGatewayConnectionListResultHandleError
	// callback for handling the HTTP response
	responder virtualNetworkGatewayConnectionListResultHandleResponse
	// callback for advancing to the next page
	advancer virtualNetworkGatewayConnectionListResultAdvancePage
	// contains the current response
	current VirtualNetworkGatewayConnectionListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualNetworkGatewayConnectionListResultPager) Err() error {
	return p.err
}

func (p *virtualNetworkGatewayConnectionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualNetworkGatewayConnectionListResult.NextLink == nil || len(*p.current.VirtualNetworkGatewayConnectionListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualNetworkGatewayConnectionListResultPager) PageResponse() VirtualNetworkGatewayConnectionListResultResponse {
	return p.current
}

// VirtualNetworkGatewayListConnectionsResultPager provides iteration over VirtualNetworkGatewayListConnectionsResult pages.
type VirtualNetworkGatewayListConnectionsResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualNetworkGatewayListConnectionsResultResponse.
	PageResponse() VirtualNetworkGatewayListConnectionsResultResponse
}

type virtualNetworkGatewayListConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualNetworkGatewayListConnectionsResultHandleError func(*azcore.Response) error

type virtualNetworkGatewayListConnectionsResultHandleResponse func(*azcore.Response) (VirtualNetworkGatewayListConnectionsResultResponse, error)

type virtualNetworkGatewayListConnectionsResultAdvancePage func(context.Context, VirtualNetworkGatewayListConnectionsResultResponse) (*azcore.Request, error)

type virtualNetworkGatewayListConnectionsResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualNetworkGatewayListConnectionsResultCreateRequest
	// callback for handling response errors
	errorer virtualNetworkGatewayListConnectionsResultHandleError
	// callback for handling the HTTP response
	responder virtualNetworkGatewayListConnectionsResultHandleResponse
	// callback for advancing to the next page
	advancer virtualNetworkGatewayListConnectionsResultAdvancePage
	// contains the current response
	current VirtualNetworkGatewayListConnectionsResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualNetworkGatewayListConnectionsResultPager) Err() error {
	return p.err
}

func (p *virtualNetworkGatewayListConnectionsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualNetworkGatewayListConnectionsResult.NextLink == nil || len(*p.current.VirtualNetworkGatewayListConnectionsResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualNetworkGatewayListConnectionsResultPager) PageResponse() VirtualNetworkGatewayListConnectionsResultResponse {
	return p.current
}

// VirtualNetworkGatewayListResultPager provides iteration over VirtualNetworkGatewayListResult pages.
type VirtualNetworkGatewayListResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualNetworkGatewayListResultResponse.
	PageResponse() VirtualNetworkGatewayListResultResponse
}

type virtualNetworkGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualNetworkGatewayListResultHandleError func(*azcore.Response) error

type virtualNetworkGatewayListResultHandleResponse func(*azcore.Response) (VirtualNetworkGatewayListResultResponse, error)

type virtualNetworkGatewayListResultAdvancePage func(context.Context, VirtualNetworkGatewayListResultResponse) (*azcore.Request, error)

type virtualNetworkGatewayListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualNetworkGatewayListResultCreateRequest
	// callback for handling response errors
	errorer virtualNetworkGatewayListResultHandleError
	// callback for handling the HTTP response
	responder virtualNetworkGatewayListResultHandleResponse
	// callback for advancing to the next page
	advancer virtualNetworkGatewayListResultAdvancePage
	// contains the current response
	current VirtualNetworkGatewayListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualNetworkGatewayListResultPager) Err() error {
	return p.err
}

func (p *virtualNetworkGatewayListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualNetworkGatewayListResult.NextLink == nil || len(*p.current.VirtualNetworkGatewayListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualNetworkGatewayListResultPager) PageResponse() VirtualNetworkGatewayListResultResponse {
	return p.current
}

// VirtualNetworkListResultPager provides iteration over VirtualNetworkListResult pages.
type VirtualNetworkListResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualNetworkListResultResponse.
	PageResponse() VirtualNetworkListResultResponse
}

type virtualNetworkListResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualNetworkListResultHandleError func(*azcore.Response) error

type virtualNetworkListResultHandleResponse func(*azcore.Response) (VirtualNetworkListResultResponse, error)

type virtualNetworkListResultAdvancePage func(context.Context, VirtualNetworkListResultResponse) (*azcore.Request, error)

type virtualNetworkListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualNetworkListResultCreateRequest
	// callback for handling response errors
	errorer virtualNetworkListResultHandleError
	// callback for handling the HTTP response
	responder virtualNetworkListResultHandleResponse
	// callback for advancing to the next page
	advancer virtualNetworkListResultAdvancePage
	// contains the current response
	current VirtualNetworkListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualNetworkListResultPager) Err() error {
	return p.err
}

func (p *virtualNetworkListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualNetworkListResult.NextLink == nil || len(*p.current.VirtualNetworkListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualNetworkListResultPager) PageResponse() VirtualNetworkListResultResponse {
	return p.current
}

// VirtualNetworkListUsageResultPager provides iteration over VirtualNetworkListUsageResult pages.
type VirtualNetworkListUsageResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualNetworkListUsageResultResponse.
	PageResponse() VirtualNetworkListUsageResultResponse
}

type virtualNetworkListUsageResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualNetworkListUsageResultHandleError func(*azcore.Response) error

type virtualNetworkListUsageResultHandleResponse func(*azcore.Response) (VirtualNetworkListUsageResultResponse, error)

type virtualNetworkListUsageResultAdvancePage func(context.Context, VirtualNetworkListUsageResultResponse) (*azcore.Request, error)

type virtualNetworkListUsageResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualNetworkListUsageResultCreateRequest
	// callback for handling response errors
	errorer virtualNetworkListUsageResultHandleError
	// callback for handling the HTTP response
	responder virtualNetworkListUsageResultHandleResponse
	// callback for advancing to the next page
	advancer virtualNetworkListUsageResultAdvancePage
	// contains the current response
	current VirtualNetworkListUsageResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualNetworkListUsageResultPager) Err() error {
	return p.err
}

func (p *virtualNetworkListUsageResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualNetworkListUsageResult.NextLink == nil || len(*p.current.VirtualNetworkListUsageResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualNetworkListUsageResultPager) PageResponse() VirtualNetworkListUsageResultResponse {
	return p.current
}

// VirtualNetworkPeeringListResultPager provides iteration over VirtualNetworkPeeringListResult pages.
type VirtualNetworkPeeringListResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualNetworkPeeringListResultResponse.
	PageResponse() VirtualNetworkPeeringListResultResponse
}

type virtualNetworkPeeringListResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualNetworkPeeringListResultHandleError func(*azcore.Response) error

type virtualNetworkPeeringListResultHandleResponse func(*azcore.Response) (VirtualNetworkPeeringListResultResponse, error)

type virtualNetworkPeeringListResultAdvancePage func(context.Context, VirtualNetworkPeeringListResultResponse) (*azcore.Request, error)

type virtualNetworkPeeringListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualNetworkPeeringListResultCreateRequest
	// callback for handling response errors
	errorer virtualNetworkPeeringListResultHandleError
	// callback for handling the HTTP response
	responder virtualNetworkPeeringListResultHandleResponse
	// callback for advancing to the next page
	advancer virtualNetworkPeeringListResultAdvancePage
	// contains the current response
	current VirtualNetworkPeeringListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualNetworkPeeringListResultPager) Err() error {
	return p.err
}

func (p *virtualNetworkPeeringListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualNetworkPeeringListResult.NextLink == nil || len(*p.current.VirtualNetworkPeeringListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualNetworkPeeringListResultPager) PageResponse() VirtualNetworkPeeringListResultResponse {
	return p.current
}

// VirtualNetworkTapListResultPager provides iteration over VirtualNetworkTapListResult pages.
type VirtualNetworkTapListResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualNetworkTapListResultResponse.
	PageResponse() VirtualNetworkTapListResultResponse
}

type virtualNetworkTapListResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualNetworkTapListResultHandleError func(*azcore.Response) error

type virtualNetworkTapListResultHandleResponse func(*azcore.Response) (VirtualNetworkTapListResultResponse, error)

type virtualNetworkTapListResultAdvancePage func(context.Context, VirtualNetworkTapListResultResponse) (*azcore.Request, error)

type virtualNetworkTapListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualNetworkTapListResultCreateRequest
	// callback for handling response errors
	errorer virtualNetworkTapListResultHandleError
	// callback for handling the HTTP response
	responder virtualNetworkTapListResultHandleResponse
	// callback for advancing to the next page
	advancer virtualNetworkTapListResultAdvancePage
	// contains the current response
	current VirtualNetworkTapListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualNetworkTapListResultPager) Err() error {
	return p.err
}

func (p *virtualNetworkTapListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualNetworkTapListResult.NextLink == nil || len(*p.current.VirtualNetworkTapListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualNetworkTapListResultPager) PageResponse() VirtualNetworkTapListResultResponse {
	return p.current
}

// VirtualRouterListResultPager provides iteration over VirtualRouterListResult pages.
type VirtualRouterListResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualRouterListResultResponse.
	PageResponse() VirtualRouterListResultResponse
}

type virtualRouterListResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualRouterListResultHandleError func(*azcore.Response) error

type virtualRouterListResultHandleResponse func(*azcore.Response) (VirtualRouterListResultResponse, error)

type virtualRouterListResultAdvancePage func(context.Context, VirtualRouterListResultResponse) (*azcore.Request, error)

type virtualRouterListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualRouterListResultCreateRequest
	// callback for handling response errors
	errorer virtualRouterListResultHandleError
	// callback for handling the HTTP response
	responder virtualRouterListResultHandleResponse
	// callback for advancing to the next page
	advancer virtualRouterListResultAdvancePage
	// contains the current response
	current VirtualRouterListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualRouterListResultPager) Err() error {
	return p.err
}

func (p *virtualRouterListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualRouterListResult.NextLink == nil || len(*p.current.VirtualRouterListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualRouterListResultPager) PageResponse() VirtualRouterListResultResponse {
	return p.current
}

// VirtualRouterPeeringListResultPager provides iteration over VirtualRouterPeeringListResult pages.
type VirtualRouterPeeringListResultPager interface {
	azcore.Pager

	// PageResponse returns the current VirtualRouterPeeringListResultResponse.
	PageResponse() VirtualRouterPeeringListResultResponse
}

type virtualRouterPeeringListResultCreateRequest func(context.Context) (*azcore.Request, error)

type virtualRouterPeeringListResultHandleError func(*azcore.Response) error

type virtualRouterPeeringListResultHandleResponse func(*azcore.Response) (VirtualRouterPeeringListResultResponse, error)

type virtualRouterPeeringListResultAdvancePage func(context.Context, VirtualRouterPeeringListResultResponse) (*azcore.Request, error)

type virtualRouterPeeringListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester virtualRouterPeeringListResultCreateRequest
	// callback for handling response errors
	errorer virtualRouterPeeringListResultHandleError
	// callback for handling the HTTP response
	responder virtualRouterPeeringListResultHandleResponse
	// callback for advancing to the next page
	advancer virtualRouterPeeringListResultAdvancePage
	// contains the current response
	current VirtualRouterPeeringListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *virtualRouterPeeringListResultPager) Err() error {
	return p.err
}

func (p *virtualRouterPeeringListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualRouterPeeringListResult.NextLink == nil || len(*p.current.VirtualRouterPeeringListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *virtualRouterPeeringListResultPager) PageResponse() VirtualRouterPeeringListResultResponse {
	return p.current
}

// WebApplicationFirewallPolicyListResultPager provides iteration over WebApplicationFirewallPolicyListResult pages.
type WebApplicationFirewallPolicyListResultPager interface {
	azcore.Pager

	// PageResponse returns the current WebApplicationFirewallPolicyListResultResponse.
	PageResponse() WebApplicationFirewallPolicyListResultResponse
}

type webApplicationFirewallPolicyListResultCreateRequest func(context.Context) (*azcore.Request, error)

type webApplicationFirewallPolicyListResultHandleError func(*azcore.Response) error

type webApplicationFirewallPolicyListResultHandleResponse func(*azcore.Response) (WebApplicationFirewallPolicyListResultResponse, error)

type webApplicationFirewallPolicyListResultAdvancePage func(context.Context, WebApplicationFirewallPolicyListResultResponse) (*azcore.Request, error)

type webApplicationFirewallPolicyListResultPager struct {
	// the pipeline for making the request
	pipeline azcore.Pipeline
	// creates the initial request (non-LRO case)
	requester webApplicationFirewallPolicyListResultCreateRequest
	// callback for handling response errors
	errorer webApplicationFirewallPolicyListResultHandleError
	// callback for handling the HTTP response
	responder webApplicationFirewallPolicyListResultHandleResponse
	// callback for advancing to the next page
	advancer webApplicationFirewallPolicyListResultAdvancePage
	// contains the current response
	current WebApplicationFirewallPolicyListResultResponse
	// status codes for successful retrieval
	statusCodes []int
	// any error encountered
	err error
}

func (p *webApplicationFirewallPolicyListResultPager) Err() error {
	return p.err
}

func (p *webApplicationFirewallPolicyListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.WebApplicationFirewallPolicyListResult.NextLink == nil || len(*p.current.WebApplicationFirewallPolicyListResult.NextLink) == 0 {
			return false
		}
		req, err = p.advancer(ctx, p.current)
	} else {
		req, err = p.requester(ctx)
	}
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.pipeline.Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !resp.HasStatusCode(p.statusCodes...) {
		p.err = p.errorer(resp)
		return false
	}
	result, err := p.responder(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}

func (p *webApplicationFirewallPolicyListResultPager) PageResponse() WebApplicationFirewallPolicyListResultResponse {
	return p.current
}