xref: /dports/www/grafana8/azure-sdk-for-go-sdk-azcore-v0.19.0/sdk/compute/armcompute/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 armcompute

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

// AvailabilitySetListResultPager provides iteration over AvailabilitySetListResult pages.
type AvailabilitySetListResultPager interface {
	azcore.Pager

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

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

type availabilitySetListResultHandleError func(*azcore.Response) error

type availabilitySetListResultHandleResponse func(*azcore.Response) (AvailabilitySetListResultResponse, error)

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

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

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

func (p *availabilitySetListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.AvailabilitySetListResult.NextLink == nil || len(*p.current.AvailabilitySetListResult.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 *availabilitySetListResultPager) PageResponse() AvailabilitySetListResultResponse {
	return p.current
}

// CloudServiceListResultPager provides iteration over CloudServiceListResult pages.
type CloudServiceListResultPager interface {
	azcore.Pager

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

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

type cloudServiceListResultHandleError func(*azcore.Response) error

type cloudServiceListResultHandleResponse func(*azcore.Response) (CloudServiceListResultResponse, error)

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

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

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

func (p *cloudServiceListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.CloudServiceListResult.NextLink == nil || len(*p.current.CloudServiceListResult.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 *cloudServiceListResultPager) PageResponse() CloudServiceListResultResponse {
	return p.current
}

// CloudServiceRoleListResultPager provides iteration over CloudServiceRoleListResult pages.
type CloudServiceRoleListResultPager interface {
	azcore.Pager

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

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

type cloudServiceRoleListResultHandleError func(*azcore.Response) error

type cloudServiceRoleListResultHandleResponse func(*azcore.Response) (CloudServiceRoleListResultResponse, error)

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

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

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

func (p *cloudServiceRoleListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.CloudServiceRoleListResult.NextLink == nil || len(*p.current.CloudServiceRoleListResult.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 *cloudServiceRoleListResultPager) PageResponse() CloudServiceRoleListResultResponse {
	return p.current
}

// DedicatedHostGroupListResultPager provides iteration over DedicatedHostGroupListResult pages.
type DedicatedHostGroupListResultPager interface {
	azcore.Pager

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

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

type dedicatedHostGroupListResultHandleError func(*azcore.Response) error

type dedicatedHostGroupListResultHandleResponse func(*azcore.Response) (DedicatedHostGroupListResultResponse, error)

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

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

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

func (p *dedicatedHostGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DedicatedHostGroupListResult.NextLink == nil || len(*p.current.DedicatedHostGroupListResult.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 *dedicatedHostGroupListResultPager) PageResponse() DedicatedHostGroupListResultResponse {
	return p.current
}

// DedicatedHostListResultPager provides iteration over DedicatedHostListResult pages.
type DedicatedHostListResultPager interface {
	azcore.Pager

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

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

type dedicatedHostListResultHandleError func(*azcore.Response) error

type dedicatedHostListResultHandleResponse func(*azcore.Response) (DedicatedHostListResultResponse, error)

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

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

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

func (p *dedicatedHostListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DedicatedHostListResult.NextLink == nil || len(*p.current.DedicatedHostListResult.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 *dedicatedHostListResultPager) PageResponse() DedicatedHostListResultResponse {
	return p.current
}

// DiskAccessListPager provides iteration over DiskAccessList pages.
type DiskAccessListPager interface {
	azcore.Pager

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

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

type diskAccessListHandleError func(*azcore.Response) error

type diskAccessListHandleResponse func(*azcore.Response) (DiskAccessListResponse, error)

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

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

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

func (p *diskAccessListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DiskAccessList.NextLink == nil || len(*p.current.DiskAccessList.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 *diskAccessListPager) PageResponse() DiskAccessListResponse {
	return p.current
}

// DiskEncryptionSetListPager provides iteration over DiskEncryptionSetList pages.
type DiskEncryptionSetListPager interface {
	azcore.Pager

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

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

type diskEncryptionSetListHandleError func(*azcore.Response) error

type diskEncryptionSetListHandleResponse func(*azcore.Response) (DiskEncryptionSetListResponse, error)

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

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

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

func (p *diskEncryptionSetListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DiskEncryptionSetList.NextLink == nil || len(*p.current.DiskEncryptionSetList.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 *diskEncryptionSetListPager) PageResponse() DiskEncryptionSetListResponse {
	return p.current
}

// DiskListPager provides iteration over DiskList pages.
type DiskListPager interface {
	azcore.Pager

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

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

type diskListHandleError func(*azcore.Response) error

type diskListHandleResponse func(*azcore.Response) (DiskListResponse, error)

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

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

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

func (p *diskListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DiskList.NextLink == nil || len(*p.current.DiskList.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 *diskListPager) PageResponse() DiskListResponse {
	return p.current
}

// DiskRestorePointListPager provides iteration over DiskRestorePointList pages.
type DiskRestorePointListPager interface {
	azcore.Pager

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

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

type diskRestorePointListHandleError func(*azcore.Response) error

type diskRestorePointListHandleResponse func(*azcore.Response) (DiskRestorePointListResponse, error)

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

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

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

func (p *diskRestorePointListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.DiskRestorePointList.NextLink == nil || len(*p.current.DiskRestorePointList.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 *diskRestorePointListPager) PageResponse() DiskRestorePointListResponse {
	return p.current
}

// GalleryApplicationListPager provides iteration over GalleryApplicationList pages.
type GalleryApplicationListPager interface {
	azcore.Pager

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

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

type galleryApplicationListHandleError func(*azcore.Response) error

type galleryApplicationListHandleResponse func(*azcore.Response) (GalleryApplicationListResponse, error)

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

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

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

func (p *galleryApplicationListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.GalleryApplicationList.NextLink == nil || len(*p.current.GalleryApplicationList.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 *galleryApplicationListPager) PageResponse() GalleryApplicationListResponse {
	return p.current
}

// GalleryApplicationVersionListPager provides iteration over GalleryApplicationVersionList pages.
type GalleryApplicationVersionListPager interface {
	azcore.Pager

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

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

type galleryApplicationVersionListHandleError func(*azcore.Response) error

type galleryApplicationVersionListHandleResponse func(*azcore.Response) (GalleryApplicationVersionListResponse, error)

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

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

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

func (p *galleryApplicationVersionListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.GalleryApplicationVersionList.NextLink == nil || len(*p.current.GalleryApplicationVersionList.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 *galleryApplicationVersionListPager) PageResponse() GalleryApplicationVersionListResponse {
	return p.current
}

// GalleryImageListPager provides iteration over GalleryImageList pages.
type GalleryImageListPager interface {
	azcore.Pager

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

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

type galleryImageListHandleError func(*azcore.Response) error

type galleryImageListHandleResponse func(*azcore.Response) (GalleryImageListResponse, error)

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

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

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

func (p *galleryImageListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.GalleryImageList.NextLink == nil || len(*p.current.GalleryImageList.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 *galleryImageListPager) PageResponse() GalleryImageListResponse {
	return p.current
}

// GalleryImageVersionListPager provides iteration over GalleryImageVersionList pages.
type GalleryImageVersionListPager interface {
	azcore.Pager

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

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

type galleryImageVersionListHandleError func(*azcore.Response) error

type galleryImageVersionListHandleResponse func(*azcore.Response) (GalleryImageVersionListResponse, error)

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

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

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

func (p *galleryImageVersionListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.GalleryImageVersionList.NextLink == nil || len(*p.current.GalleryImageVersionList.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 *galleryImageVersionListPager) PageResponse() GalleryImageVersionListResponse {
	return p.current
}

// GalleryListPager provides iteration over GalleryList pages.
type GalleryListPager interface {
	azcore.Pager

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

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

type galleryListHandleError func(*azcore.Response) error

type galleryListHandleResponse func(*azcore.Response) (GalleryListResponse, error)

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

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

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

func (p *galleryListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.GalleryList.NextLink == nil || len(*p.current.GalleryList.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 *galleryListPager) PageResponse() GalleryListResponse {
	return p.current
}

// ImageListResultPager provides iteration over ImageListResult pages.
type ImageListResultPager interface {
	azcore.Pager

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

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

type imageListResultHandleError func(*azcore.Response) error

type imageListResultHandleResponse func(*azcore.Response) (ImageListResultResponse, error)

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

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

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

func (p *imageListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ImageListResult.NextLink == nil || len(*p.current.ImageListResult.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 *imageListResultPager) PageResponse() ImageListResultResponse {
	return p.current
}

// ListUsagesResultPager provides iteration over ListUsagesResult pages.
type ListUsagesResultPager interface {
	azcore.Pager

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

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

type listUsagesResultHandleError func(*azcore.Response) error

type listUsagesResultHandleResponse func(*azcore.Response) (ListUsagesResultResponse, error)

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

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

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

func (p *listUsagesResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ListUsagesResult.NextLink == nil || len(*p.current.ListUsagesResult.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 *listUsagesResultPager) PageResponse() ListUsagesResultResponse {
	return p.current
}

// OSFamilyListResultPager provides iteration over OSFamilyListResult pages.
type OSFamilyListResultPager interface {
	azcore.Pager

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

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

type osFamilyListResultHandleError func(*azcore.Response) error

type osFamilyListResultHandleResponse func(*azcore.Response) (OSFamilyListResultResponse, error)

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

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

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

func (p *osFamilyListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.OSFamilyListResult.NextLink == nil || len(*p.current.OSFamilyListResult.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 *osFamilyListResultPager) PageResponse() OSFamilyListResultResponse {
	return p.current
}

// OSVersionListResultPager provides iteration over OSVersionListResult pages.
type OSVersionListResultPager interface {
	azcore.Pager

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

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

type osVersionListResultHandleError func(*azcore.Response) error

type osVersionListResultHandleResponse func(*azcore.Response) (OSVersionListResultResponse, error)

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

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

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

func (p *osVersionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.OSVersionListResult.NextLink == nil || len(*p.current.OSVersionListResult.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 *osVersionListResultPager) PageResponse() OSVersionListResultResponse {
	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
}

// ProximityPlacementGroupListResultPager provides iteration over ProximityPlacementGroupListResult pages.
type ProximityPlacementGroupListResultPager interface {
	azcore.Pager

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

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

type proximityPlacementGroupListResultHandleError func(*azcore.Response) error

type proximityPlacementGroupListResultHandleResponse func(*azcore.Response) (ProximityPlacementGroupListResultResponse, error)

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

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

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

func (p *proximityPlacementGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProximityPlacementGroupListResult.NextLink == nil || len(*p.current.ProximityPlacementGroupListResult.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 *proximityPlacementGroupListResultPager) PageResponse() ProximityPlacementGroupListResultResponse {
	return p.current
}

// ResourceSKUsResultPager provides iteration over ResourceSKUsResult pages.
type ResourceSKUsResultPager interface {
	azcore.Pager

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

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

type resourceSKUsResultHandleError func(*azcore.Response) error

type resourceSKUsResultHandleResponse func(*azcore.Response) (ResourceSKUsResultResponse, error)

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

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

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

func (p *resourceSKUsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ResourceSKUsResult.NextLink == nil || len(*p.current.ResourceSKUsResult.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 *resourceSKUsResultPager) PageResponse() ResourceSKUsResultResponse {
	return p.current
}

// ResourceURIListPager provides iteration over ResourceURIList pages.
type ResourceURIListPager interface {
	azcore.Pager

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

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

type resourceURIListHandleError func(*azcore.Response) error

type resourceURIListHandleResponse func(*azcore.Response) (ResourceURIListResponse, error)

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

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

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

func (p *resourceURIListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ResourceURIList.NextLink == nil || len(*p.current.ResourceURIList.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 *resourceURIListPager) PageResponse() ResourceURIListResponse {
	return p.current
}

// RestorePointCollectionListResultPager provides iteration over RestorePointCollectionListResult pages.
type RestorePointCollectionListResultPager interface {
	azcore.Pager

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

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

type restorePointCollectionListResultHandleError func(*azcore.Response) error

type restorePointCollectionListResultHandleResponse func(*azcore.Response) (RestorePointCollectionListResultResponse, error)

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

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

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

func (p *restorePointCollectionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.RestorePointCollectionListResult.NextLink == nil || len(*p.current.RestorePointCollectionListResult.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 *restorePointCollectionListResultPager) PageResponse() RestorePointCollectionListResultResponse {
	return p.current
}

// RoleInstanceListResultPager provides iteration over RoleInstanceListResult pages.
type RoleInstanceListResultPager interface {
	azcore.Pager

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

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

type roleInstanceListResultHandleError func(*azcore.Response) error

type roleInstanceListResultHandleResponse func(*azcore.Response) (RoleInstanceListResultResponse, error)

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

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

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

func (p *roleInstanceListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.RoleInstanceListResult.NextLink == nil || len(*p.current.RoleInstanceListResult.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 *roleInstanceListResultPager) PageResponse() RoleInstanceListResultResponse {
	return p.current
}

// RunCommandListResultPager provides iteration over RunCommandListResult pages.
type RunCommandListResultPager interface {
	azcore.Pager

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

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

type runCommandListResultHandleError func(*azcore.Response) error

type runCommandListResultHandleResponse func(*azcore.Response) (RunCommandListResultResponse, error)

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

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

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

func (p *runCommandListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.RunCommandListResult.NextLink == nil || len(*p.current.RunCommandListResult.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 *runCommandListResultPager) PageResponse() RunCommandListResultResponse {
	return p.current
}

// SSHPublicKeysGroupListResultPager provides iteration over SSHPublicKeysGroupListResult pages.
type SSHPublicKeysGroupListResultPager interface {
	azcore.Pager

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

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

type sshPublicKeysGroupListResultHandleError func(*azcore.Response) error

type sshPublicKeysGroupListResultHandleResponse func(*azcore.Response) (SSHPublicKeysGroupListResultResponse, error)

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

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

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

func (p *sshPublicKeysGroupListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SSHPublicKeysGroupListResult.NextLink == nil || len(*p.current.SSHPublicKeysGroupListResult.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 *sshPublicKeysGroupListResultPager) PageResponse() SSHPublicKeysGroupListResultResponse {
	return p.current
}

// SharedGalleryImageListPager provides iteration over SharedGalleryImageList pages.
type SharedGalleryImageListPager interface {
	azcore.Pager

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

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

type sharedGalleryImageListHandleError func(*azcore.Response) error

type sharedGalleryImageListHandleResponse func(*azcore.Response) (SharedGalleryImageListResponse, error)

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

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

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

func (p *sharedGalleryImageListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SharedGalleryImageList.NextLink == nil || len(*p.current.SharedGalleryImageList.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 *sharedGalleryImageListPager) PageResponse() SharedGalleryImageListResponse {
	return p.current
}

// SharedGalleryImageVersionListPager provides iteration over SharedGalleryImageVersionList pages.
type SharedGalleryImageVersionListPager interface {
	azcore.Pager

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

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

type sharedGalleryImageVersionListHandleError func(*azcore.Response) error

type sharedGalleryImageVersionListHandleResponse func(*azcore.Response) (SharedGalleryImageVersionListResponse, error)

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

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

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

func (p *sharedGalleryImageVersionListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SharedGalleryImageVersionList.NextLink == nil || len(*p.current.SharedGalleryImageVersionList.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 *sharedGalleryImageVersionListPager) PageResponse() SharedGalleryImageVersionListResponse {
	return p.current
}

// SharedGalleryListPager provides iteration over SharedGalleryList pages.
type SharedGalleryListPager interface {
	azcore.Pager

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

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

type sharedGalleryListHandleError func(*azcore.Response) error

type sharedGalleryListHandleResponse func(*azcore.Response) (SharedGalleryListResponse, error)

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

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

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

func (p *sharedGalleryListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SharedGalleryList.NextLink == nil || len(*p.current.SharedGalleryList.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 *sharedGalleryListPager) PageResponse() SharedGalleryListResponse {
	return p.current
}

// SnapshotListPager provides iteration over SnapshotList pages.
type SnapshotListPager interface {
	azcore.Pager

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

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

type snapshotListHandleError func(*azcore.Response) error

type snapshotListHandleResponse func(*azcore.Response) (SnapshotListResponse, error)

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

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

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

func (p *snapshotListPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.SnapshotList.NextLink == nil || len(*p.current.SnapshotList.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 *snapshotListPager) PageResponse() SnapshotListResponse {
	return p.current
}

// UpdateDomainListResultPager provides iteration over UpdateDomainListResult pages.
type UpdateDomainListResultPager interface {
	azcore.Pager

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

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

type updateDomainListResultHandleError func(*azcore.Response) error

type updateDomainListResultHandleResponse func(*azcore.Response) (UpdateDomainListResultResponse, error)

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

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

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

func (p *updateDomainListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.UpdateDomainListResult.NextLink == nil || len(*p.current.UpdateDomainListResult.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 *updateDomainListResultPager) PageResponse() UpdateDomainListResultResponse {
	return p.current
}

// VirtualMachineListResultPager provides iteration over VirtualMachineListResult pages.
type VirtualMachineListResultPager interface {
	azcore.Pager

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

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

type virtualMachineListResultHandleError func(*azcore.Response) error

type virtualMachineListResultHandleResponse func(*azcore.Response) (VirtualMachineListResultResponse, error)

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

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

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

func (p *virtualMachineListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineListResult.NextLink == nil || len(*p.current.VirtualMachineListResult.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 *virtualMachineListResultPager) PageResponse() VirtualMachineListResultResponse {
	return p.current
}

// VirtualMachineRunCommandsListResultPager provides iteration over VirtualMachineRunCommandsListResult pages.
type VirtualMachineRunCommandsListResultPager interface {
	azcore.Pager

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

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

type virtualMachineRunCommandsListResultHandleError func(*azcore.Response) error

type virtualMachineRunCommandsListResultHandleResponse func(*azcore.Response) (VirtualMachineRunCommandsListResultResponse, error)

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

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

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

func (p *virtualMachineRunCommandsListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineRunCommandsListResult.NextLink == nil || len(*p.current.VirtualMachineRunCommandsListResult.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 *virtualMachineRunCommandsListResultPager) PageResponse() VirtualMachineRunCommandsListResultResponse {
	return p.current
}

// VirtualMachineScaleSetExtensionListResultPager provides iteration over VirtualMachineScaleSetExtensionListResult pages.
type VirtualMachineScaleSetExtensionListResultPager interface {
	azcore.Pager

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

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

type virtualMachineScaleSetExtensionListResultHandleError func(*azcore.Response) error

type virtualMachineScaleSetExtensionListResultHandleResponse func(*azcore.Response) (VirtualMachineScaleSetExtensionListResultResponse, error)

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

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

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

func (p *virtualMachineScaleSetExtensionListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineScaleSetExtensionListResult.NextLink == nil || len(*p.current.VirtualMachineScaleSetExtensionListResult.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 *virtualMachineScaleSetExtensionListResultPager) PageResponse() VirtualMachineScaleSetExtensionListResultResponse {
	return p.current
}

// VirtualMachineScaleSetListOSUpgradeHistoryPager provides iteration over VirtualMachineScaleSetListOSUpgradeHistory pages.
type VirtualMachineScaleSetListOSUpgradeHistoryPager interface {
	azcore.Pager

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

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

type virtualMachineScaleSetListOSUpgradeHistoryHandleError func(*azcore.Response) error

type virtualMachineScaleSetListOSUpgradeHistoryHandleResponse func(*azcore.Response) (VirtualMachineScaleSetListOSUpgradeHistoryResponse, error)

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

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

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

func (p *virtualMachineScaleSetListOSUpgradeHistoryPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineScaleSetListOSUpgradeHistory.NextLink == nil || len(*p.current.VirtualMachineScaleSetListOSUpgradeHistory.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 *virtualMachineScaleSetListOSUpgradeHistoryPager) PageResponse() VirtualMachineScaleSetListOSUpgradeHistoryResponse {
	return p.current
}

// VirtualMachineScaleSetListResultPager provides iteration over VirtualMachineScaleSetListResult pages.
type VirtualMachineScaleSetListResultPager interface {
	azcore.Pager

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

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

type virtualMachineScaleSetListResultHandleError func(*azcore.Response) error

type virtualMachineScaleSetListResultHandleResponse func(*azcore.Response) (VirtualMachineScaleSetListResultResponse, error)

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

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

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

func (p *virtualMachineScaleSetListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineScaleSetListResult.NextLink == nil || len(*p.current.VirtualMachineScaleSetListResult.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 *virtualMachineScaleSetListResultPager) PageResponse() VirtualMachineScaleSetListResultResponse {
	return p.current
}

// VirtualMachineScaleSetListSKUsResultPager provides iteration over VirtualMachineScaleSetListSKUsResult pages.
type VirtualMachineScaleSetListSKUsResultPager interface {
	azcore.Pager

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

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

type virtualMachineScaleSetListSKUsResultHandleError func(*azcore.Response) error

type virtualMachineScaleSetListSKUsResultHandleResponse func(*azcore.Response) (VirtualMachineScaleSetListSKUsResultResponse, error)

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

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

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

func (p *virtualMachineScaleSetListSKUsResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineScaleSetListSKUsResult.NextLink == nil || len(*p.current.VirtualMachineScaleSetListSKUsResult.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 *virtualMachineScaleSetListSKUsResultPager) PageResponse() VirtualMachineScaleSetListSKUsResultResponse {
	return p.current
}

// VirtualMachineScaleSetListWithLinkResultPager provides iteration over VirtualMachineScaleSetListWithLinkResult pages.
type VirtualMachineScaleSetListWithLinkResultPager interface {
	azcore.Pager

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

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

type virtualMachineScaleSetListWithLinkResultHandleError func(*azcore.Response) error

type virtualMachineScaleSetListWithLinkResultHandleResponse func(*azcore.Response) (VirtualMachineScaleSetListWithLinkResultResponse, error)

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

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

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

func (p *virtualMachineScaleSetListWithLinkResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineScaleSetListWithLinkResult.NextLink == nil || len(*p.current.VirtualMachineScaleSetListWithLinkResult.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 *virtualMachineScaleSetListWithLinkResultPager) PageResponse() VirtualMachineScaleSetListWithLinkResultResponse {
	return p.current
}

// VirtualMachineScaleSetVMListResultPager provides iteration over VirtualMachineScaleSetVMListResult pages.
type VirtualMachineScaleSetVMListResultPager interface {
	azcore.Pager

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

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

type virtualMachineScaleSetVMListResultHandleError func(*azcore.Response) error

type virtualMachineScaleSetVMListResultHandleResponse func(*azcore.Response) (VirtualMachineScaleSetVMListResultResponse, error)

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

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

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

func (p *virtualMachineScaleSetVMListResultPager) NextPage(ctx context.Context) bool {
	var req *azcore.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.VirtualMachineScaleSetVMListResult.NextLink == nil || len(*p.current.VirtualMachineScaleSetVMListResult.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 *virtualMachineScaleSetVMListResultPager) PageResponse() VirtualMachineScaleSetVMListResultResponse {
	return p.current
}