func (p *PagingGetMultiplePagesRetrySecondPager) PageResponse() PagingGetMultiplePagesRetrySecondResponse {
	return p.current
}
PageResponse returns the current PagingGetMultiplePagesRetrySecondResponse page.
package paginggroup
import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
	"reflect"
)
type PagingFirstResponseEmptyPager struct {
	client    *PagingClient
	current   PagingFirstResponseEmptyResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingFirstResponseEmptyResponse) (*policy.Request, error)
}
func (p *PagingFirstResponseEmptyPager) Err() error {
	return p.err
}
func (p *PagingFirstResponseEmptyPager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProductResultValue.NextLink == nil || len(*p.current.ProductResultValue.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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.firstResponseEmptyHandleError(resp)
		return false
	}
	result, err := p.client.firstResponseEmptyHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingFirstResponseEmptyPager) PageResponse() PagingFirstResponseEmptyResponse {
	return p.current
}
type PagingGetMultiplePagesFailurePager struct {
	client    *PagingClient
	current   PagingGetMultiplePagesFailureResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingGetMultiplePagesFailureResponse) (*policy.Request, error)
}
func (p *PagingGetMultiplePagesFailurePager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesFailurePager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProductResult.NextLink == nil || len(*p.current.ProductResult.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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.getMultiplePagesFailureHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesFailureHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingGetMultiplePagesFailurePager) PageResponse() PagingGetMultiplePagesFailureResponse {
	return p.current
}
type PagingGetMultiplePagesFailureURIPager struct {
	client    *PagingClient
	current   PagingGetMultiplePagesFailureURIResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingGetMultiplePagesFailureURIResponse) (*policy.Request, error)
}
func (p *PagingGetMultiplePagesFailureURIPager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesFailureURIPager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProductResult.NextLink == nil || len(*p.current.ProductResult.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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.getMultiplePagesFailureURIHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesFailureURIHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingGetMultiplePagesFailureURIPager) PageResponse() PagingGetMultiplePagesFailureURIResponse {
	return p.current
}
type PagingGetMultiplePagesFragmentNextLinkPager struct {
	client    *PagingClient
	current   PagingGetMultiplePagesFragmentNextLinkResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingGetMultiplePagesFragmentNextLinkResponse) (*policy.Request, error)
}
func (p *PagingGetMultiplePagesFragmentNextLinkPager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesFragmentNextLinkPager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ODataProductResult.ODataNextLink == nil || len(*p.current.ODataProductResult.ODataNextLink) == 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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.getMultiplePagesFragmentNextLinkHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesFragmentNextLinkHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingGetMultiplePagesFragmentNextLinkPager) PageResponse() PagingGetMultiplePagesFragmentNextLinkResponse {
	return p.current
}
type PagingGetMultiplePagesFragmentWithGroupingNextLinkPager struct {
	client    *PagingClient
	current   PagingGetMultiplePagesFragmentWithGroupingNextLinkResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingGetMultiplePagesFragmentWithGroupingNextLinkResponse) (*policy.Request, error)
}
func (p *PagingGetMultiplePagesFragmentWithGroupingNextLinkPager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesFragmentWithGroupingNextLinkPager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ODataProductResult.ODataNextLink == nil || len(*p.current.ODataProductResult.ODataNextLink) == 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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.getMultiplePagesFragmentWithGroupingNextLinkHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesFragmentWithGroupingNextLinkHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingGetMultiplePagesFragmentWithGroupingNextLinkPager) PageResponse() PagingGetMultiplePagesFragmentWithGroupingNextLinkResponse {
	return p.current
}
type PagingGetMultiplePagesLROPager struct {
	client  *PagingClient
	current PagingGetMultiplePagesLROResponse
	err     error
	second  bool
}
func (p *PagingGetMultiplePagesLROPager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesLROPager) NextPage(ctx context.Context) bool {
	if !p.second {
		p.second = true
		return true
	} else if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProductResult.NextLink == nil || len(*p.current.ProductResult.NextLink) == 0 {
			return false
		}
	}
	req, err := runtime.NewRequest(ctx, http.MethodGet, *p.current.ProductResult.NextLink)
	if err != nil {
		p.err = err
		return false
	}
	resp, err := p.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted) {
		p.err = p.client.getMultiplePagesLROHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesLROHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingGetMultiplePagesLROPager) PageResponse() PagingGetMultiplePagesLROResponse {
	return p.current
}
type PagingGetMultiplePagesPager struct {
	client    *PagingClient
	current   PagingGetMultiplePagesResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingGetMultiplePagesResponse) (*policy.Request, error)
}
func (p *PagingGetMultiplePagesPager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesPager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProductResult.NextLink == nil || len(*p.current.ProductResult.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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.getMultiplePagesHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingGetMultiplePagesPager) PageResponse() PagingGetMultiplePagesResponse {
	return p.current
}
type PagingGetMultiplePagesRetryFirstPager struct {
	client    *PagingClient
	current   PagingGetMultiplePagesRetryFirstResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingGetMultiplePagesRetryFirstResponse) (*policy.Request, error)
}
func (p *PagingGetMultiplePagesRetryFirstPager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesRetryFirstPager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProductResult.NextLink == nil || len(*p.current.ProductResult.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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.getMultiplePagesRetryFirstHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesRetryFirstHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}
func (p *PagingGetMultiplePagesRetryFirstPager) PageResponse() PagingGetMultiplePagesRetryFirstResponse {
	return p.current
}
type PagingGetMultiplePagesRetrySecondPager struct {
	client    *PagingClient
	current   PagingGetMultiplePagesRetrySecondResponse
	err       error
	requester func(context.Context) (*policy.Request, error)
	advancer  func(context.Context, PagingGetMultiplePagesRetrySecondResponse) (*policy.Request, error)
}
func (p *PagingGetMultiplePagesRetrySecondPager) Err() error {
	return p.err
}
func (p *PagingGetMultiplePagesRetrySecondPager) NextPage(ctx context.Context) bool {
	var req *policy.Request
	var err error
	if !reflect.ValueOf(p.current).IsZero() {
		if p.current.ProductResult.NextLink == nil || len(*p.current.ProductResult.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.client.con.Pipeline().Do(req)
	if err != nil {
		p.err = err
		return false
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		p.err = p.client.getMultiplePagesRetrySecondHandleError(resp)
		return false
	}
	result, err := p.client.getMultiplePagesRetrySecondHandleResponse(resp)
	if err != nil {
		p.err = err
		return false
	}
	p.current = result
	return true
}