network/armnetwork/zz_generated_pollers.go

// +build go1.13

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

package armnetwork

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"net/http"
	"time"
)

// ApplicationGatewayBackendHealthOnDemandPoller provides polling facilities until the operation reaches a terminal state.
type ApplicationGatewayBackendHealthOnDemandPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ApplicationGatewayBackendHealthOnDemandResponse will be returned.
	FinalResponse(ctx context.Context) (ApplicationGatewayBackendHealthOnDemandResponse, error)
}

type applicationGatewayBackendHealthOnDemandPoller struct {
	pt *armcore.LROPoller
}

func (p *applicationGatewayBackendHealthOnDemandPoller) Done() bool {
	return p.pt.Done()
}

func (p *applicationGatewayBackendHealthOnDemandPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *applicationGatewayBackendHealthOnDemandPoller) FinalResponse(ctx context.Context) (ApplicationGatewayBackendHealthOnDemandResponse, error) {
	respType := ApplicationGatewayBackendHealthOnDemandResponse{ApplicationGatewayBackendHealthOnDemand: &ApplicationGatewayBackendHealthOnDemand{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ApplicationGatewayBackendHealthOnDemand)
	if err != nil {
		return ApplicationGatewayBackendHealthOnDemandResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *applicationGatewayBackendHealthOnDemandPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *applicationGatewayBackendHealthOnDemandPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ApplicationGatewayBackendHealthOnDemandResponse, error) {
	respType := ApplicationGatewayBackendHealthOnDemandResponse{ApplicationGatewayBackendHealthOnDemand: &ApplicationGatewayBackendHealthOnDemand{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ApplicationGatewayBackendHealthOnDemand)
	if err != nil {
		return ApplicationGatewayBackendHealthOnDemandResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ApplicationGatewayBackendHealthPoller provides polling facilities until the operation reaches a terminal state.
type ApplicationGatewayBackendHealthPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ApplicationGatewayBackendHealthResponse will be returned.
	FinalResponse(ctx context.Context) (ApplicationGatewayBackendHealthResponse, error)
}

type applicationGatewayBackendHealthPoller struct {
	pt *armcore.LROPoller
}

func (p *applicationGatewayBackendHealthPoller) Done() bool {
	return p.pt.Done()
}

func (p *applicationGatewayBackendHealthPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *applicationGatewayBackendHealthPoller) FinalResponse(ctx context.Context) (ApplicationGatewayBackendHealthResponse, error) {
	respType := ApplicationGatewayBackendHealthResponse{ApplicationGatewayBackendHealth: &ApplicationGatewayBackendHealth{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ApplicationGatewayBackendHealth)
	if err != nil {
		return ApplicationGatewayBackendHealthResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *applicationGatewayBackendHealthPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *applicationGatewayBackendHealthPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ApplicationGatewayBackendHealthResponse, error) {
	respType := ApplicationGatewayBackendHealthResponse{ApplicationGatewayBackendHealth: &ApplicationGatewayBackendHealth{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ApplicationGatewayBackendHealth)
	if err != nil {
		return ApplicationGatewayBackendHealthResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ApplicationGatewayPoller provides polling facilities until the operation reaches a terminal state.
type ApplicationGatewayPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ApplicationGatewayResponse will be returned.
	FinalResponse(ctx context.Context) (ApplicationGatewayResponse, error)
}

type applicationGatewayPoller struct {
	pt *armcore.LROPoller
}

func (p *applicationGatewayPoller) Done() bool {
	return p.pt.Done()
}

func (p *applicationGatewayPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *applicationGatewayPoller) FinalResponse(ctx context.Context) (ApplicationGatewayResponse, error) {
	respType := ApplicationGatewayResponse{ApplicationGateway: &ApplicationGateway{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ApplicationGateway)
	if err != nil {
		return ApplicationGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *applicationGatewayPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *applicationGatewayPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ApplicationGatewayResponse, error) {
	respType := ApplicationGatewayResponse{ApplicationGateway: &ApplicationGateway{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ApplicationGateway)
	if err != nil {
		return ApplicationGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ApplicationGatewayPrivateEndpointConnectionPoller provides polling facilities until the operation reaches a terminal state.
type ApplicationGatewayPrivateEndpointConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ApplicationGatewayPrivateEndpointConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (ApplicationGatewayPrivateEndpointConnectionResponse, error)
}

type applicationGatewayPrivateEndpointConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *applicationGatewayPrivateEndpointConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *applicationGatewayPrivateEndpointConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *applicationGatewayPrivateEndpointConnectionPoller) FinalResponse(ctx context.Context) (ApplicationGatewayPrivateEndpointConnectionResponse, error) {
	respType := ApplicationGatewayPrivateEndpointConnectionResponse{ApplicationGatewayPrivateEndpointConnection: &ApplicationGatewayPrivateEndpointConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ApplicationGatewayPrivateEndpointConnection)
	if err != nil {
		return ApplicationGatewayPrivateEndpointConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *applicationGatewayPrivateEndpointConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *applicationGatewayPrivateEndpointConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ApplicationGatewayPrivateEndpointConnectionResponse, error) {
	respType := ApplicationGatewayPrivateEndpointConnectionResponse{ApplicationGatewayPrivateEndpointConnection: &ApplicationGatewayPrivateEndpointConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ApplicationGatewayPrivateEndpointConnection)
	if err != nil {
		return ApplicationGatewayPrivateEndpointConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ApplicationSecurityGroupPoller provides polling facilities until the operation reaches a terminal state.
type ApplicationSecurityGroupPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ApplicationSecurityGroupResponse will be returned.
	FinalResponse(ctx context.Context) (ApplicationSecurityGroupResponse, error)
}

type applicationSecurityGroupPoller struct {
	pt *armcore.LROPoller
}

func (p *applicationSecurityGroupPoller) Done() bool {
	return p.pt.Done()
}

func (p *applicationSecurityGroupPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *applicationSecurityGroupPoller) FinalResponse(ctx context.Context) (ApplicationSecurityGroupResponse, error) {
	respType := ApplicationSecurityGroupResponse{ApplicationSecurityGroup: &ApplicationSecurityGroup{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ApplicationSecurityGroup)
	if err != nil {
		return ApplicationSecurityGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *applicationSecurityGroupPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *applicationSecurityGroupPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ApplicationSecurityGroupResponse, error) {
	respType := ApplicationSecurityGroupResponse{ApplicationSecurityGroup: &ApplicationSecurityGroup{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ApplicationSecurityGroup)
	if err != nil {
		return ApplicationSecurityGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// AvailableProvidersListPoller provides polling facilities until the operation reaches a terminal state.
type AvailableProvidersListPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final AvailableProvidersListResponse will be returned.
	FinalResponse(ctx context.Context) (AvailableProvidersListResponse, error)
}

type availableProvidersListPoller struct {
	pt *armcore.LROPoller
}

func (p *availableProvidersListPoller) Done() bool {
	return p.pt.Done()
}

func (p *availableProvidersListPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *availableProvidersListPoller) FinalResponse(ctx context.Context) (AvailableProvidersListResponse, error) {
	respType := AvailableProvidersListResponse{AvailableProvidersList: &AvailableProvidersList{}}
	resp, err := p.pt.FinalResponse(ctx, respType.AvailableProvidersList)
	if err != nil {
		return AvailableProvidersListResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *availableProvidersListPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *availableProvidersListPoller) pollUntilDone(ctx context.Context, freq time.Duration) (AvailableProvidersListResponse, error) {
	respType := AvailableProvidersListResponse{AvailableProvidersList: &AvailableProvidersList{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.AvailableProvidersList)
	if err != nil {
		return AvailableProvidersListResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// AzureFirewallPoller provides polling facilities until the operation reaches a terminal state.
type AzureFirewallPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final AzureFirewallResponse will be returned.
	FinalResponse(ctx context.Context) (AzureFirewallResponse, error)
}

type azureFirewallPoller struct {
	pt *armcore.LROPoller
}

func (p *azureFirewallPoller) Done() bool {
	return p.pt.Done()
}

func (p *azureFirewallPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *azureFirewallPoller) FinalResponse(ctx context.Context) (AzureFirewallResponse, error) {
	respType := AzureFirewallResponse{AzureFirewall: &AzureFirewall{}}
	resp, err := p.pt.FinalResponse(ctx, respType.AzureFirewall)
	if err != nil {
		return AzureFirewallResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *azureFirewallPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *azureFirewallPoller) pollUntilDone(ctx context.Context, freq time.Duration) (AzureFirewallResponse, error) {
	respType := AzureFirewallResponse{AzureFirewall: &AzureFirewall{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.AzureFirewall)
	if err != nil {
		return AzureFirewallResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// AzureReachabilityReportPoller provides polling facilities until the operation reaches a terminal state.
type AzureReachabilityReportPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final AzureReachabilityReportResponse will be returned.
	FinalResponse(ctx context.Context) (AzureReachabilityReportResponse, error)
}

type azureReachabilityReportPoller struct {
	pt *armcore.LROPoller
}

func (p *azureReachabilityReportPoller) Done() bool {
	return p.pt.Done()
}

func (p *azureReachabilityReportPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *azureReachabilityReportPoller) FinalResponse(ctx context.Context) (AzureReachabilityReportResponse, error) {
	respType := AzureReachabilityReportResponse{AzureReachabilityReport: &AzureReachabilityReport{}}
	resp, err := p.pt.FinalResponse(ctx, respType.AzureReachabilityReport)
	if err != nil {
		return AzureReachabilityReportResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *azureReachabilityReportPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *azureReachabilityReportPoller) pollUntilDone(ctx context.Context, freq time.Duration) (AzureReachabilityReportResponse, error) {
	respType := AzureReachabilityReportResponse{AzureReachabilityReport: &AzureReachabilityReport{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.AzureReachabilityReport)
	if err != nil {
		return AzureReachabilityReportResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// BackendAddressPoolPoller provides polling facilities until the operation reaches a terminal state.
type BackendAddressPoolPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final BackendAddressPoolResponse will be returned.
	FinalResponse(ctx context.Context) (BackendAddressPoolResponse, error)
}

type backendAddressPoolPoller struct {
	pt *armcore.LROPoller
}

func (p *backendAddressPoolPoller) Done() bool {
	return p.pt.Done()
}

func (p *backendAddressPoolPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *backendAddressPoolPoller) FinalResponse(ctx context.Context) (BackendAddressPoolResponse, error) {
	respType := BackendAddressPoolResponse{BackendAddressPool: &BackendAddressPool{}}
	resp, err := p.pt.FinalResponse(ctx, respType.BackendAddressPool)
	if err != nil {
		return BackendAddressPoolResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *backendAddressPoolPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *backendAddressPoolPoller) pollUntilDone(ctx context.Context, freq time.Duration) (BackendAddressPoolResponse, error) {
	respType := BackendAddressPoolResponse{BackendAddressPool: &BackendAddressPool{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.BackendAddressPool)
	if err != nil {
		return BackendAddressPoolResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// BastionActiveSessionListResultPagerPoller provides polling facilities until the operation reaches a terminal state.
type BastionActiveSessionListResultPagerPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final BastionActiveSessionListResultPager will be returned.
	FinalResponse(ctx context.Context) (BastionActiveSessionListResultPager, error)
}

type bastionActiveSessionListResultPagerPoller struct {
	pt          *armcore.LROPoller
	errHandler  bastionActiveSessionListResultHandleError
	respHandler bastionActiveSessionListResultHandleResponse
	statusCodes []int
}

func (p *bastionActiveSessionListResultPagerPoller) Done() bool {
	return p.pt.Done()
}

func (p *bastionActiveSessionListResultPagerPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *bastionActiveSessionListResultPagerPoller) FinalResponse(ctx context.Context) (BastionActiveSessionListResultPager, error) {
	respType := &bastionActiveSessionListResultPager{}
	resp, err := p.pt.FinalResponse(ctx, respType)
	if err != nil {
		return nil, err
	}
	return p.handleResponse(&azcore.Response{Response: resp})
}

func (p *bastionActiveSessionListResultPagerPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *bastionActiveSessionListResultPagerPoller) pollUntilDone(ctx context.Context, freq time.Duration) (BastionActiveSessionListResultPager, error) {
	respType := &bastionActiveSessionListResultPager{}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType)
	if err != nil {
		return nil, err
	}
	return p.handleResponse(&azcore.Response{Response: resp})
}

func (p *bastionActiveSessionListResultPagerPoller) handleResponse(resp *azcore.Response) (BastionActiveSessionListResultPager, error) {
	return &bastionActiveSessionListResultPager{
		pipeline:  p.pt.Pipeline,
		resp:      resp,
		errorer:   p.errHandler,
		responder: p.respHandler,
		advancer: func(ctx context.Context, resp BastionActiveSessionListResultResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.BastionActiveSessionListResult.NextLink)
		},
		statusCodes: p.statusCodes,
	}, nil
}

// BastionHostPoller provides polling facilities until the operation reaches a terminal state.
type BastionHostPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final BastionHostResponse will be returned.
	FinalResponse(ctx context.Context) (BastionHostResponse, error)
}

type bastionHostPoller struct {
	pt *armcore.LROPoller
}

func (p *bastionHostPoller) Done() bool {
	return p.pt.Done()
}

func (p *bastionHostPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *bastionHostPoller) FinalResponse(ctx context.Context) (BastionHostResponse, error) {
	respType := BastionHostResponse{BastionHost: &BastionHost{}}
	resp, err := p.pt.FinalResponse(ctx, respType.BastionHost)
	if err != nil {
		return BastionHostResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *bastionHostPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *bastionHostPoller) pollUntilDone(ctx context.Context, freq time.Duration) (BastionHostResponse, error) {
	respType := BastionHostResponse{BastionHost: &BastionHost{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.BastionHost)
	if err != nil {
		return BastionHostResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// BastionShareableLinkListResultPagerPoller provides polling facilities until the operation reaches a terminal state.
type BastionShareableLinkListResultPagerPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final BastionShareableLinkListResultPager will be returned.
	FinalResponse(ctx context.Context) (BastionShareableLinkListResultPager, error)
}

type bastionShareableLinkListResultPagerPoller struct {
	pt          *armcore.LROPoller
	errHandler  bastionShareableLinkListResultHandleError
	respHandler bastionShareableLinkListResultHandleResponse
	statusCodes []int
}

func (p *bastionShareableLinkListResultPagerPoller) Done() bool {
	return p.pt.Done()
}

func (p *bastionShareableLinkListResultPagerPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *bastionShareableLinkListResultPagerPoller) FinalResponse(ctx context.Context) (BastionShareableLinkListResultPager, error) {
	respType := &bastionShareableLinkListResultPager{}
	resp, err := p.pt.FinalResponse(ctx, respType)
	if err != nil {
		return nil, err
	}
	return p.handleResponse(&azcore.Response{Response: resp})
}

func (p *bastionShareableLinkListResultPagerPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *bastionShareableLinkListResultPagerPoller) pollUntilDone(ctx context.Context, freq time.Duration) (BastionShareableLinkListResultPager, error) {
	respType := &bastionShareableLinkListResultPager{}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType)
	if err != nil {
		return nil, err
	}
	return p.handleResponse(&azcore.Response{Response: resp})
}

func (p *bastionShareableLinkListResultPagerPoller) handleResponse(resp *azcore.Response) (BastionShareableLinkListResultPager, error) {
	return &bastionShareableLinkListResultPager{
		pipeline:  p.pt.Pipeline,
		resp:      resp,
		errorer:   p.errHandler,
		responder: p.respHandler,
		advancer: func(ctx context.Context, resp BastionShareableLinkListResultResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.BastionShareableLinkListResult.NextLink)
		},
		statusCodes: p.statusCodes,
	}, nil
}

// BgpConnectionPoller provides polling facilities until the operation reaches a terminal state.
type BgpConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final BgpConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (BgpConnectionResponse, error)
}

type bgpConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *bgpConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *bgpConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *bgpConnectionPoller) FinalResponse(ctx context.Context) (BgpConnectionResponse, error) {
	respType := BgpConnectionResponse{BgpConnection: &BgpConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.BgpConnection)
	if err != nil {
		return BgpConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *bgpConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *bgpConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (BgpConnectionResponse, error) {
	respType := BgpConnectionResponse{BgpConnection: &BgpConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.BgpConnection)
	if err != nil {
		return BgpConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// BgpPeerStatusListResultPoller provides polling facilities until the operation reaches a terminal state.
type BgpPeerStatusListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final BgpPeerStatusListResultResponse will be returned.
	FinalResponse(ctx context.Context) (BgpPeerStatusListResultResponse, error)
}

type bgpPeerStatusListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *bgpPeerStatusListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *bgpPeerStatusListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *bgpPeerStatusListResultPoller) FinalResponse(ctx context.Context) (BgpPeerStatusListResultResponse, error) {
	respType := BgpPeerStatusListResultResponse{BgpPeerStatusListResult: &BgpPeerStatusListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.BgpPeerStatusListResult)
	if err != nil {
		return BgpPeerStatusListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *bgpPeerStatusListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *bgpPeerStatusListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (BgpPeerStatusListResultResponse, error) {
	respType := BgpPeerStatusListResultResponse{BgpPeerStatusListResult: &BgpPeerStatusListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.BgpPeerStatusListResult)
	if err != nil {
		return BgpPeerStatusListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ConnectionMonitorQueryResultPoller provides polling facilities until the operation reaches a terminal state.
type ConnectionMonitorQueryResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ConnectionMonitorQueryResultResponse will be returned.
	FinalResponse(ctx context.Context) (ConnectionMonitorQueryResultResponse, error)
}

type connectionMonitorQueryResultPoller struct {
	pt *armcore.LROPoller
}

func (p *connectionMonitorQueryResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *connectionMonitorQueryResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *connectionMonitorQueryResultPoller) FinalResponse(ctx context.Context) (ConnectionMonitorQueryResultResponse, error) {
	respType := ConnectionMonitorQueryResultResponse{ConnectionMonitorQueryResult: &ConnectionMonitorQueryResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ConnectionMonitorQueryResult)
	if err != nil {
		return ConnectionMonitorQueryResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *connectionMonitorQueryResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *connectionMonitorQueryResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ConnectionMonitorQueryResultResponse, error) {
	respType := ConnectionMonitorQueryResultResponse{ConnectionMonitorQueryResult: &ConnectionMonitorQueryResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ConnectionMonitorQueryResult)
	if err != nil {
		return ConnectionMonitorQueryResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ConnectionMonitorResultPoller provides polling facilities until the operation reaches a terminal state.
type ConnectionMonitorResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ConnectionMonitorResultResponse will be returned.
	FinalResponse(ctx context.Context) (ConnectionMonitorResultResponse, error)
}

type connectionMonitorResultPoller struct {
	pt *armcore.LROPoller
}

func (p *connectionMonitorResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *connectionMonitorResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *connectionMonitorResultPoller) FinalResponse(ctx context.Context) (ConnectionMonitorResultResponse, error) {
	respType := ConnectionMonitorResultResponse{ConnectionMonitorResult: &ConnectionMonitorResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ConnectionMonitorResult)
	if err != nil {
		return ConnectionMonitorResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *connectionMonitorResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *connectionMonitorResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ConnectionMonitorResultResponse, error) {
	respType := ConnectionMonitorResultResponse{ConnectionMonitorResult: &ConnectionMonitorResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ConnectionMonitorResult)
	if err != nil {
		return ConnectionMonitorResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ConnectionResetSharedKeyPoller provides polling facilities until the operation reaches a terminal state.
type ConnectionResetSharedKeyPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ConnectionResetSharedKeyResponse will be returned.
	FinalResponse(ctx context.Context) (ConnectionResetSharedKeyResponse, error)
}

type connectionResetSharedKeyPoller struct {
	pt *armcore.LROPoller
}

func (p *connectionResetSharedKeyPoller) Done() bool {
	return p.pt.Done()
}

func (p *connectionResetSharedKeyPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *connectionResetSharedKeyPoller) FinalResponse(ctx context.Context) (ConnectionResetSharedKeyResponse, error) {
	respType := ConnectionResetSharedKeyResponse{ConnectionResetSharedKey: &ConnectionResetSharedKey{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ConnectionResetSharedKey)
	if err != nil {
		return ConnectionResetSharedKeyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *connectionResetSharedKeyPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *connectionResetSharedKeyPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ConnectionResetSharedKeyResponse, error) {
	respType := ConnectionResetSharedKeyResponse{ConnectionResetSharedKey: &ConnectionResetSharedKey{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ConnectionResetSharedKey)
	if err != nil {
		return ConnectionResetSharedKeyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ConnectionSharedKeyPoller provides polling facilities until the operation reaches a terminal state.
type ConnectionSharedKeyPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ConnectionSharedKeyResponse will be returned.
	FinalResponse(ctx context.Context) (ConnectionSharedKeyResponse, error)
}

type connectionSharedKeyPoller struct {
	pt *armcore.LROPoller
}

func (p *connectionSharedKeyPoller) Done() bool {
	return p.pt.Done()
}

func (p *connectionSharedKeyPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *connectionSharedKeyPoller) FinalResponse(ctx context.Context) (ConnectionSharedKeyResponse, error) {
	respType := ConnectionSharedKeyResponse{ConnectionSharedKey: &ConnectionSharedKey{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ConnectionSharedKey)
	if err != nil {
		return ConnectionSharedKeyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *connectionSharedKeyPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *connectionSharedKeyPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ConnectionSharedKeyResponse, error) {
	respType := ConnectionSharedKeyResponse{ConnectionSharedKey: &ConnectionSharedKey{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ConnectionSharedKey)
	if err != nil {
		return ConnectionSharedKeyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ConnectivityInformationPoller provides polling facilities until the operation reaches a terminal state.
type ConnectivityInformationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ConnectivityInformationResponse will be returned.
	FinalResponse(ctx context.Context) (ConnectivityInformationResponse, error)
}

type connectivityInformationPoller struct {
	pt *armcore.LROPoller
}

func (p *connectivityInformationPoller) Done() bool {
	return p.pt.Done()
}

func (p *connectivityInformationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *connectivityInformationPoller) FinalResponse(ctx context.Context) (ConnectivityInformationResponse, error) {
	respType := ConnectivityInformationResponse{ConnectivityInformation: &ConnectivityInformation{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ConnectivityInformation)
	if err != nil {
		return ConnectivityInformationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *connectivityInformationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *connectivityInformationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ConnectivityInformationResponse, error) {
	respType := ConnectivityInformationResponse{ConnectivityInformation: &ConnectivityInformation{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ConnectivityInformation)
	if err != nil {
		return ConnectivityInformationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// CustomIPPrefixPoller provides polling facilities until the operation reaches a terminal state.
type CustomIPPrefixPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final CustomIPPrefixResponse will be returned.
	FinalResponse(ctx context.Context) (CustomIPPrefixResponse, error)
}

type customIPPrefixPoller struct {
	pt *armcore.LROPoller
}

func (p *customIPPrefixPoller) Done() bool {
	return p.pt.Done()
}

func (p *customIPPrefixPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *customIPPrefixPoller) FinalResponse(ctx context.Context) (CustomIPPrefixResponse, error) {
	respType := CustomIPPrefixResponse{CustomIPPrefix: &CustomIPPrefix{}}
	resp, err := p.pt.FinalResponse(ctx, respType.CustomIPPrefix)
	if err != nil {
		return CustomIPPrefixResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *customIPPrefixPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *customIPPrefixPoller) pollUntilDone(ctx context.Context, freq time.Duration) (CustomIPPrefixResponse, error) {
	respType := CustomIPPrefixResponse{CustomIPPrefix: &CustomIPPrefix{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.CustomIPPrefix)
	if err != nil {
		return CustomIPPrefixResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// DdosCustomPolicyPoller provides polling facilities until the operation reaches a terminal state.
type DdosCustomPolicyPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final DdosCustomPolicyResponse will be returned.
	FinalResponse(ctx context.Context) (DdosCustomPolicyResponse, error)
}

type ddosCustomPolicyPoller struct {
	pt *armcore.LROPoller
}

func (p *ddosCustomPolicyPoller) Done() bool {
	return p.pt.Done()
}

func (p *ddosCustomPolicyPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *ddosCustomPolicyPoller) FinalResponse(ctx context.Context) (DdosCustomPolicyResponse, error) {
	respType := DdosCustomPolicyResponse{DdosCustomPolicy: &DdosCustomPolicy{}}
	resp, err := p.pt.FinalResponse(ctx, respType.DdosCustomPolicy)
	if err != nil {
		return DdosCustomPolicyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *ddosCustomPolicyPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *ddosCustomPolicyPoller) pollUntilDone(ctx context.Context, freq time.Duration) (DdosCustomPolicyResponse, error) {
	respType := DdosCustomPolicyResponse{DdosCustomPolicy: &DdosCustomPolicy{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.DdosCustomPolicy)
	if err != nil {
		return DdosCustomPolicyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// DdosProtectionPlanPoller provides polling facilities until the operation reaches a terminal state.
type DdosProtectionPlanPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final DdosProtectionPlanResponse will be returned.
	FinalResponse(ctx context.Context) (DdosProtectionPlanResponse, error)
}

type ddosProtectionPlanPoller struct {
	pt *armcore.LROPoller
}

func (p *ddosProtectionPlanPoller) Done() bool {
	return p.pt.Done()
}

func (p *ddosProtectionPlanPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *ddosProtectionPlanPoller) FinalResponse(ctx context.Context) (DdosProtectionPlanResponse, error) {
	respType := DdosProtectionPlanResponse{DdosProtectionPlan: &DdosProtectionPlan{}}
	resp, err := p.pt.FinalResponse(ctx, respType.DdosProtectionPlan)
	if err != nil {
		return DdosProtectionPlanResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *ddosProtectionPlanPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *ddosProtectionPlanPoller) pollUntilDone(ctx context.Context, freq time.Duration) (DdosProtectionPlanResponse, error) {
	respType := DdosProtectionPlanResponse{DdosProtectionPlan: &DdosProtectionPlan{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.DdosProtectionPlan)
	if err != nil {
		return DdosProtectionPlanResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// DscpConfigurationPoller provides polling facilities until the operation reaches a terminal state.
type DscpConfigurationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final DscpConfigurationResponse will be returned.
	FinalResponse(ctx context.Context) (DscpConfigurationResponse, error)
}

type dscpConfigurationPoller struct {
	pt *armcore.LROPoller
}

func (p *dscpConfigurationPoller) Done() bool {
	return p.pt.Done()
}

func (p *dscpConfigurationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *dscpConfigurationPoller) FinalResponse(ctx context.Context) (DscpConfigurationResponse, error) {
	respType := DscpConfigurationResponse{DscpConfiguration: &DscpConfiguration{}}
	resp, err := p.pt.FinalResponse(ctx, respType.DscpConfiguration)
	if err != nil {
		return DscpConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *dscpConfigurationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *dscpConfigurationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (DscpConfigurationResponse, error) {
	respType := DscpConfigurationResponse{DscpConfiguration: &DscpConfiguration{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.DscpConfiguration)
	if err != nil {
		return DscpConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// EffectiveNetworkSecurityGroupListResultPoller provides polling facilities until the operation reaches a terminal state.
type EffectiveNetworkSecurityGroupListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final EffectiveNetworkSecurityGroupListResultResponse will be returned.
	FinalResponse(ctx context.Context) (EffectiveNetworkSecurityGroupListResultResponse, error)
}

type effectiveNetworkSecurityGroupListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *effectiveNetworkSecurityGroupListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *effectiveNetworkSecurityGroupListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *effectiveNetworkSecurityGroupListResultPoller) FinalResponse(ctx context.Context) (EffectiveNetworkSecurityGroupListResultResponse, error) {
	respType := EffectiveNetworkSecurityGroupListResultResponse{EffectiveNetworkSecurityGroupListResult: &EffectiveNetworkSecurityGroupListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.EffectiveNetworkSecurityGroupListResult)
	if err != nil {
		return EffectiveNetworkSecurityGroupListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *effectiveNetworkSecurityGroupListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *effectiveNetworkSecurityGroupListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (EffectiveNetworkSecurityGroupListResultResponse, error) {
	respType := EffectiveNetworkSecurityGroupListResultResponse{EffectiveNetworkSecurityGroupListResult: &EffectiveNetworkSecurityGroupListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.EffectiveNetworkSecurityGroupListResult)
	if err != nil {
		return EffectiveNetworkSecurityGroupListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// EffectiveRouteListResultPoller provides polling facilities until the operation reaches a terminal state.
type EffectiveRouteListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final EffectiveRouteListResultResponse will be returned.
	FinalResponse(ctx context.Context) (EffectiveRouteListResultResponse, error)
}

type effectiveRouteListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *effectiveRouteListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *effectiveRouteListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *effectiveRouteListResultPoller) FinalResponse(ctx context.Context) (EffectiveRouteListResultResponse, error) {
	respType := EffectiveRouteListResultResponse{EffectiveRouteListResult: &EffectiveRouteListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.EffectiveRouteListResult)
	if err != nil {
		return EffectiveRouteListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *effectiveRouteListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *effectiveRouteListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (EffectiveRouteListResultResponse, error) {
	respType := EffectiveRouteListResultResponse{EffectiveRouteListResult: &EffectiveRouteListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.EffectiveRouteListResult)
	if err != nil {
		return EffectiveRouteListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCircuitAuthorizationPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCircuitAuthorizationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCircuitAuthorizationResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCircuitAuthorizationResponse, error)
}

type expressRouteCircuitAuthorizationPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCircuitAuthorizationPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCircuitAuthorizationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCircuitAuthorizationPoller) FinalResponse(ctx context.Context) (ExpressRouteCircuitAuthorizationResponse, error) {
	respType := ExpressRouteCircuitAuthorizationResponse{ExpressRouteCircuitAuthorization: &ExpressRouteCircuitAuthorization{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCircuitAuthorization)
	if err != nil {
		return ExpressRouteCircuitAuthorizationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCircuitAuthorizationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCircuitAuthorizationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCircuitAuthorizationResponse, error) {
	respType := ExpressRouteCircuitAuthorizationResponse{ExpressRouteCircuitAuthorization: &ExpressRouteCircuitAuthorization{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCircuitAuthorization)
	if err != nil {
		return ExpressRouteCircuitAuthorizationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCircuitConnectionPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCircuitConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCircuitConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCircuitConnectionResponse, error)
}

type expressRouteCircuitConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCircuitConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCircuitConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCircuitConnectionPoller) FinalResponse(ctx context.Context) (ExpressRouteCircuitConnectionResponse, error) {
	respType := ExpressRouteCircuitConnectionResponse{ExpressRouteCircuitConnection: &ExpressRouteCircuitConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCircuitConnection)
	if err != nil {
		return ExpressRouteCircuitConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCircuitConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCircuitConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCircuitConnectionResponse, error) {
	respType := ExpressRouteCircuitConnectionResponse{ExpressRouteCircuitConnection: &ExpressRouteCircuitConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCircuitConnection)
	if err != nil {
		return ExpressRouteCircuitConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCircuitPeeringPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCircuitPeeringPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCircuitPeeringResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCircuitPeeringResponse, error)
}

type expressRouteCircuitPeeringPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCircuitPeeringPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCircuitPeeringPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCircuitPeeringPoller) FinalResponse(ctx context.Context) (ExpressRouteCircuitPeeringResponse, error) {
	respType := ExpressRouteCircuitPeeringResponse{ExpressRouteCircuitPeering: &ExpressRouteCircuitPeering{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCircuitPeering)
	if err != nil {
		return ExpressRouteCircuitPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCircuitPeeringPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCircuitPeeringPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCircuitPeeringResponse, error) {
	respType := ExpressRouteCircuitPeeringResponse{ExpressRouteCircuitPeering: &ExpressRouteCircuitPeering{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCircuitPeering)
	if err != nil {
		return ExpressRouteCircuitPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCircuitPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCircuitPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCircuitResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCircuitResponse, error)
}

type expressRouteCircuitPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCircuitPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCircuitPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCircuitPoller) FinalResponse(ctx context.Context) (ExpressRouteCircuitResponse, error) {
	respType := ExpressRouteCircuitResponse{ExpressRouteCircuit: &ExpressRouteCircuit{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCircuit)
	if err != nil {
		return ExpressRouteCircuitResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCircuitPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCircuitPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCircuitResponse, error) {
	respType := ExpressRouteCircuitResponse{ExpressRouteCircuit: &ExpressRouteCircuit{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCircuit)
	if err != nil {
		return ExpressRouteCircuitResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCircuitsArpTableListResultPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCircuitsArpTableListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCircuitsArpTableListResultResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCircuitsArpTableListResultResponse, error)
}

type expressRouteCircuitsArpTableListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCircuitsArpTableListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCircuitsArpTableListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCircuitsArpTableListResultPoller) FinalResponse(ctx context.Context) (ExpressRouteCircuitsArpTableListResultResponse, error) {
	respType := ExpressRouteCircuitsArpTableListResultResponse{ExpressRouteCircuitsArpTableListResult: &ExpressRouteCircuitsArpTableListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCircuitsArpTableListResult)
	if err != nil {
		return ExpressRouteCircuitsArpTableListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCircuitsArpTableListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCircuitsArpTableListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCircuitsArpTableListResultResponse, error) {
	respType := ExpressRouteCircuitsArpTableListResultResponse{ExpressRouteCircuitsArpTableListResult: &ExpressRouteCircuitsArpTableListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCircuitsArpTableListResult)
	if err != nil {
		return ExpressRouteCircuitsArpTableListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCircuitsRoutesTableListResultPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCircuitsRoutesTableListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCircuitsRoutesTableListResultResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCircuitsRoutesTableListResultResponse, error)
}

type expressRouteCircuitsRoutesTableListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCircuitsRoutesTableListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCircuitsRoutesTableListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCircuitsRoutesTableListResultPoller) FinalResponse(ctx context.Context) (ExpressRouteCircuitsRoutesTableListResultResponse, error) {
	respType := ExpressRouteCircuitsRoutesTableListResultResponse{ExpressRouteCircuitsRoutesTableListResult: &ExpressRouteCircuitsRoutesTableListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCircuitsRoutesTableListResult)
	if err != nil {
		return ExpressRouteCircuitsRoutesTableListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCircuitsRoutesTableListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCircuitsRoutesTableListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCircuitsRoutesTableListResultResponse, error) {
	respType := ExpressRouteCircuitsRoutesTableListResultResponse{ExpressRouteCircuitsRoutesTableListResult: &ExpressRouteCircuitsRoutesTableListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCircuitsRoutesTableListResult)
	if err != nil {
		return ExpressRouteCircuitsRoutesTableListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCircuitsRoutesTableSummaryListResultPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCircuitsRoutesTableSummaryListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCircuitsRoutesTableSummaryListResultResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCircuitsRoutesTableSummaryListResultResponse, error)
}

type expressRouteCircuitsRoutesTableSummaryListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCircuitsRoutesTableSummaryListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCircuitsRoutesTableSummaryListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCircuitsRoutesTableSummaryListResultPoller) FinalResponse(ctx context.Context) (ExpressRouteCircuitsRoutesTableSummaryListResultResponse, error) {
	respType := ExpressRouteCircuitsRoutesTableSummaryListResultResponse{ExpressRouteCircuitsRoutesTableSummaryListResult: &ExpressRouteCircuitsRoutesTableSummaryListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCircuitsRoutesTableSummaryListResult)
	if err != nil {
		return ExpressRouteCircuitsRoutesTableSummaryListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCircuitsRoutesTableSummaryListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCircuitsRoutesTableSummaryListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCircuitsRoutesTableSummaryListResultResponse, error) {
	respType := ExpressRouteCircuitsRoutesTableSummaryListResultResponse{ExpressRouteCircuitsRoutesTableSummaryListResult: &ExpressRouteCircuitsRoutesTableSummaryListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCircuitsRoutesTableSummaryListResult)
	if err != nil {
		return ExpressRouteCircuitsRoutesTableSummaryListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteConnectionPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteConnectionResponse, error)
}

type expressRouteConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteConnectionPoller) FinalResponse(ctx context.Context) (ExpressRouteConnectionResponse, error) {
	respType := ExpressRouteConnectionResponse{ExpressRouteConnection: &ExpressRouteConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteConnection)
	if err != nil {
		return ExpressRouteConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteConnectionResponse, error) {
	respType := ExpressRouteConnectionResponse{ExpressRouteConnection: &ExpressRouteConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteConnection)
	if err != nil {
		return ExpressRouteConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCrossConnectionPeeringPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCrossConnectionPeeringPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCrossConnectionPeeringResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCrossConnectionPeeringResponse, error)
}

type expressRouteCrossConnectionPeeringPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCrossConnectionPeeringPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCrossConnectionPeeringPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCrossConnectionPeeringPoller) FinalResponse(ctx context.Context) (ExpressRouteCrossConnectionPeeringResponse, error) {
	respType := ExpressRouteCrossConnectionPeeringResponse{ExpressRouteCrossConnectionPeering: &ExpressRouteCrossConnectionPeering{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCrossConnectionPeering)
	if err != nil {
		return ExpressRouteCrossConnectionPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCrossConnectionPeeringPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCrossConnectionPeeringPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCrossConnectionPeeringResponse, error) {
	respType := ExpressRouteCrossConnectionPeeringResponse{ExpressRouteCrossConnectionPeering: &ExpressRouteCrossConnectionPeering{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCrossConnectionPeering)
	if err != nil {
		return ExpressRouteCrossConnectionPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCrossConnectionPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCrossConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCrossConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCrossConnectionResponse, error)
}

type expressRouteCrossConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCrossConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCrossConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCrossConnectionPoller) FinalResponse(ctx context.Context) (ExpressRouteCrossConnectionResponse, error) {
	respType := ExpressRouteCrossConnectionResponse{ExpressRouteCrossConnection: &ExpressRouteCrossConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCrossConnection)
	if err != nil {
		return ExpressRouteCrossConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCrossConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCrossConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCrossConnectionResponse, error) {
	respType := ExpressRouteCrossConnectionResponse{ExpressRouteCrossConnection: &ExpressRouteCrossConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCrossConnection)
	if err != nil {
		return ExpressRouteCrossConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteCrossConnectionsRoutesTableSummaryListResultPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteCrossConnectionsRoutesTableSummaryListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse, error)
}

type expressRouteCrossConnectionsRoutesTableSummaryListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteCrossConnectionsRoutesTableSummaryListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteCrossConnectionsRoutesTableSummaryListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteCrossConnectionsRoutesTableSummaryListResultPoller) FinalResponse(ctx context.Context) (ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse, error) {
	respType := ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse{ExpressRouteCrossConnectionsRoutesTableSummaryListResult: &ExpressRouteCrossConnectionsRoutesTableSummaryListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteCrossConnectionsRoutesTableSummaryListResult)
	if err != nil {
		return ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteCrossConnectionsRoutesTableSummaryListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteCrossConnectionsRoutesTableSummaryListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse, error) {
	respType := ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse{ExpressRouteCrossConnectionsRoutesTableSummaryListResult: &ExpressRouteCrossConnectionsRoutesTableSummaryListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteCrossConnectionsRoutesTableSummaryListResult)
	if err != nil {
		return ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRouteGatewayPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRouteGatewayPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRouteGatewayResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRouteGatewayResponse, error)
}

type expressRouteGatewayPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRouteGatewayPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRouteGatewayPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRouteGatewayPoller) FinalResponse(ctx context.Context) (ExpressRouteGatewayResponse, error) {
	respType := ExpressRouteGatewayResponse{ExpressRouteGateway: &ExpressRouteGateway{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRouteGateway)
	if err != nil {
		return ExpressRouteGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRouteGatewayPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRouteGatewayPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRouteGatewayResponse, error) {
	respType := ExpressRouteGatewayResponse{ExpressRouteGateway: &ExpressRouteGateway{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRouteGateway)
	if err != nil {
		return ExpressRouteGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ExpressRoutePortPoller provides polling facilities until the operation reaches a terminal state.
type ExpressRoutePortPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ExpressRoutePortResponse will be returned.
	FinalResponse(ctx context.Context) (ExpressRoutePortResponse, error)
}

type expressRoutePortPoller struct {
	pt *armcore.LROPoller
}

func (p *expressRoutePortPoller) Done() bool {
	return p.pt.Done()
}

func (p *expressRoutePortPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *expressRoutePortPoller) FinalResponse(ctx context.Context) (ExpressRoutePortResponse, error) {
	respType := ExpressRoutePortResponse{ExpressRoutePort: &ExpressRoutePort{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ExpressRoutePort)
	if err != nil {
		return ExpressRoutePortResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *expressRoutePortPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *expressRoutePortPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ExpressRoutePortResponse, error) {
	respType := ExpressRoutePortResponse{ExpressRoutePort: &ExpressRoutePort{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ExpressRoutePort)
	if err != nil {
		return ExpressRoutePortResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// FirewallPolicyPoller provides polling facilities until the operation reaches a terminal state.
type FirewallPolicyPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final FirewallPolicyResponse will be returned.
	FinalResponse(ctx context.Context) (FirewallPolicyResponse, error)
}

type firewallPolicyPoller struct {
	pt *armcore.LROPoller
}

func (p *firewallPolicyPoller) Done() bool {
	return p.pt.Done()
}

func (p *firewallPolicyPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *firewallPolicyPoller) FinalResponse(ctx context.Context) (FirewallPolicyResponse, error) {
	respType := FirewallPolicyResponse{FirewallPolicy: &FirewallPolicy{}}
	resp, err := p.pt.FinalResponse(ctx, respType.FirewallPolicy)
	if err != nil {
		return FirewallPolicyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *firewallPolicyPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *firewallPolicyPoller) pollUntilDone(ctx context.Context, freq time.Duration) (FirewallPolicyResponse, error) {
	respType := FirewallPolicyResponse{FirewallPolicy: &FirewallPolicy{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.FirewallPolicy)
	if err != nil {
		return FirewallPolicyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// FirewallPolicyRuleCollectionGroupPoller provides polling facilities until the operation reaches a terminal state.
type FirewallPolicyRuleCollectionGroupPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final FirewallPolicyRuleCollectionGroupResponse will be returned.
	FinalResponse(ctx context.Context) (FirewallPolicyRuleCollectionGroupResponse, error)
}

type firewallPolicyRuleCollectionGroupPoller struct {
	pt *armcore.LROPoller
}

func (p *firewallPolicyRuleCollectionGroupPoller) Done() bool {
	return p.pt.Done()
}

func (p *firewallPolicyRuleCollectionGroupPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *firewallPolicyRuleCollectionGroupPoller) FinalResponse(ctx context.Context) (FirewallPolicyRuleCollectionGroupResponse, error) {
	respType := FirewallPolicyRuleCollectionGroupResponse{FirewallPolicyRuleCollectionGroup: &FirewallPolicyRuleCollectionGroup{}}
	resp, err := p.pt.FinalResponse(ctx, respType.FirewallPolicyRuleCollectionGroup)
	if err != nil {
		return FirewallPolicyRuleCollectionGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *firewallPolicyRuleCollectionGroupPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *firewallPolicyRuleCollectionGroupPoller) pollUntilDone(ctx context.Context, freq time.Duration) (FirewallPolicyRuleCollectionGroupResponse, error) {
	respType := FirewallPolicyRuleCollectionGroupResponse{FirewallPolicyRuleCollectionGroup: &FirewallPolicyRuleCollectionGroup{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.FirewallPolicyRuleCollectionGroup)
	if err != nil {
		return FirewallPolicyRuleCollectionGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// FlowLogInformationPoller provides polling facilities until the operation reaches a terminal state.
type FlowLogInformationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final FlowLogInformationResponse will be returned.
	FinalResponse(ctx context.Context) (FlowLogInformationResponse, error)
}

type flowLogInformationPoller struct {
	pt *armcore.LROPoller
}

func (p *flowLogInformationPoller) Done() bool {
	return p.pt.Done()
}

func (p *flowLogInformationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *flowLogInformationPoller) FinalResponse(ctx context.Context) (FlowLogInformationResponse, error) {
	respType := FlowLogInformationResponse{FlowLogInformation: &FlowLogInformation{}}
	resp, err := p.pt.FinalResponse(ctx, respType.FlowLogInformation)
	if err != nil {
		return FlowLogInformationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *flowLogInformationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *flowLogInformationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (FlowLogInformationResponse, error) {
	respType := FlowLogInformationResponse{FlowLogInformation: &FlowLogInformation{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.FlowLogInformation)
	if err != nil {
		return FlowLogInformationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// FlowLogPoller provides polling facilities until the operation reaches a terminal state.
type FlowLogPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final FlowLogResponse will be returned.
	FinalResponse(ctx context.Context) (FlowLogResponse, error)
}

type flowLogPoller struct {
	pt *armcore.LROPoller
}

func (p *flowLogPoller) Done() bool {
	return p.pt.Done()
}

func (p *flowLogPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *flowLogPoller) FinalResponse(ctx context.Context) (FlowLogResponse, error) {
	respType := FlowLogResponse{FlowLog: &FlowLog{}}
	resp, err := p.pt.FinalResponse(ctx, respType.FlowLog)
	if err != nil {
		return FlowLogResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *flowLogPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *flowLogPoller) pollUntilDone(ctx context.Context, freq time.Duration) (FlowLogResponse, error) {
	respType := FlowLogResponse{FlowLog: &FlowLog{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.FlowLog)
	if err != nil {
		return FlowLogResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// GatewayRouteListResultPoller provides polling facilities until the operation reaches a terminal state.
type GatewayRouteListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final GatewayRouteListResultResponse will be returned.
	FinalResponse(ctx context.Context) (GatewayRouteListResultResponse, error)
}

type gatewayRouteListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *gatewayRouteListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *gatewayRouteListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *gatewayRouteListResultPoller) FinalResponse(ctx context.Context) (GatewayRouteListResultResponse, error) {
	respType := GatewayRouteListResultResponse{GatewayRouteListResult: &GatewayRouteListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.GatewayRouteListResult)
	if err != nil {
		return GatewayRouteListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *gatewayRouteListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *gatewayRouteListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (GatewayRouteListResultResponse, error) {
	respType := GatewayRouteListResultResponse{GatewayRouteListResult: &GatewayRouteListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.GatewayRouteListResult)
	if err != nil {
		return GatewayRouteListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// HTTPPoller provides polling facilities until the operation reaches a terminal state.
type HTTPPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final *http.Response will be returned.
	FinalResponse(ctx context.Context) (*http.Response, error)
}

type httpPoller struct {
	pt *armcore.LROPoller
}

func (p *httpPoller) Done() bool {
	return p.pt.Done()
}

func (p *httpPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *httpPoller) FinalResponse(ctx context.Context) (*http.Response, error) {
	return p.pt.FinalResponse(ctx, nil)
}

func (p *httpPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *httpPoller) pollUntilDone(ctx context.Context, freq time.Duration) (*http.Response, error) {
	return p.pt.PollUntilDone(ctx, freq, nil)
}

// HubIPConfigurationPoller provides polling facilities until the operation reaches a terminal state.
type HubIPConfigurationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final HubIPConfigurationResponse will be returned.
	FinalResponse(ctx context.Context) (HubIPConfigurationResponse, error)
}

type hubIPConfigurationPoller struct {
	pt *armcore.LROPoller
}

func (p *hubIPConfigurationPoller) Done() bool {
	return p.pt.Done()
}

func (p *hubIPConfigurationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *hubIPConfigurationPoller) FinalResponse(ctx context.Context) (HubIPConfigurationResponse, error) {
	respType := HubIPConfigurationResponse{HubIPConfiguration: &HubIPConfiguration{}}
	resp, err := p.pt.FinalResponse(ctx, respType.HubIPConfiguration)
	if err != nil {
		return HubIPConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *hubIPConfigurationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *hubIPConfigurationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (HubIPConfigurationResponse, error) {
	respType := HubIPConfigurationResponse{HubIPConfiguration: &HubIPConfiguration{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.HubIPConfiguration)
	if err != nil {
		return HubIPConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// HubRouteTablePoller provides polling facilities until the operation reaches a terminal state.
type HubRouteTablePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final HubRouteTableResponse will be returned.
	FinalResponse(ctx context.Context) (HubRouteTableResponse, error)
}

type hubRouteTablePoller struct {
	pt *armcore.LROPoller
}

func (p *hubRouteTablePoller) Done() bool {
	return p.pt.Done()
}

func (p *hubRouteTablePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *hubRouteTablePoller) FinalResponse(ctx context.Context) (HubRouteTableResponse, error) {
	respType := HubRouteTableResponse{HubRouteTable: &HubRouteTable{}}
	resp, err := p.pt.FinalResponse(ctx, respType.HubRouteTable)
	if err != nil {
		return HubRouteTableResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *hubRouteTablePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *hubRouteTablePoller) pollUntilDone(ctx context.Context, freq time.Duration) (HubRouteTableResponse, error) {
	respType := HubRouteTableResponse{HubRouteTable: &HubRouteTable{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.HubRouteTable)
	if err != nil {
		return HubRouteTableResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// HubVirtualNetworkConnectionPoller provides polling facilities until the operation reaches a terminal state.
type HubVirtualNetworkConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final HubVirtualNetworkConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (HubVirtualNetworkConnectionResponse, error)
}

type hubVirtualNetworkConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *hubVirtualNetworkConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *hubVirtualNetworkConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *hubVirtualNetworkConnectionPoller) FinalResponse(ctx context.Context) (HubVirtualNetworkConnectionResponse, error) {
	respType := HubVirtualNetworkConnectionResponse{HubVirtualNetworkConnection: &HubVirtualNetworkConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.HubVirtualNetworkConnection)
	if err != nil {
		return HubVirtualNetworkConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *hubVirtualNetworkConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *hubVirtualNetworkConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (HubVirtualNetworkConnectionResponse, error) {
	respType := HubVirtualNetworkConnectionResponse{HubVirtualNetworkConnection: &HubVirtualNetworkConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.HubVirtualNetworkConnection)
	if err != nil {
		return HubVirtualNetworkConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// IPAllocationPoller provides polling facilities until the operation reaches a terminal state.
type IPAllocationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final IPAllocationResponse will be returned.
	FinalResponse(ctx context.Context) (IPAllocationResponse, error)
}

type ipAllocationPoller struct {
	pt *armcore.LROPoller
}

func (p *ipAllocationPoller) Done() bool {
	return p.pt.Done()
}

func (p *ipAllocationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *ipAllocationPoller) FinalResponse(ctx context.Context) (IPAllocationResponse, error) {
	respType := IPAllocationResponse{IPAllocation: &IPAllocation{}}
	resp, err := p.pt.FinalResponse(ctx, respType.IPAllocation)
	if err != nil {
		return IPAllocationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *ipAllocationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *ipAllocationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (IPAllocationResponse, error) {
	respType := IPAllocationResponse{IPAllocation: &IPAllocation{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.IPAllocation)
	if err != nil {
		return IPAllocationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// IPGroupPoller provides polling facilities until the operation reaches a terminal state.
type IPGroupPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final IPGroupResponse will be returned.
	FinalResponse(ctx context.Context) (IPGroupResponse, error)
}

type ipGroupPoller struct {
	pt *armcore.LROPoller
}

func (p *ipGroupPoller) Done() bool {
	return p.pt.Done()
}

func (p *ipGroupPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *ipGroupPoller) FinalResponse(ctx context.Context) (IPGroupResponse, error) {
	respType := IPGroupResponse{IPGroup: &IPGroup{}}
	resp, err := p.pt.FinalResponse(ctx, respType.IPGroup)
	if err != nil {
		return IPGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *ipGroupPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *ipGroupPoller) pollUntilDone(ctx context.Context, freq time.Duration) (IPGroupResponse, error) {
	respType := IPGroupResponse{IPGroup: &IPGroup{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.IPGroup)
	if err != nil {
		return IPGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// InboundNatRulePoller provides polling facilities until the operation reaches a terminal state.
type InboundNatRulePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final InboundNatRuleResponse will be returned.
	FinalResponse(ctx context.Context) (InboundNatRuleResponse, error)
}

type inboundNatRulePoller struct {
	pt *armcore.LROPoller
}

func (p *inboundNatRulePoller) Done() bool {
	return p.pt.Done()
}

func (p *inboundNatRulePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *inboundNatRulePoller) FinalResponse(ctx context.Context) (InboundNatRuleResponse, error) {
	respType := InboundNatRuleResponse{InboundNatRule: &InboundNatRule{}}
	resp, err := p.pt.FinalResponse(ctx, respType.InboundNatRule)
	if err != nil {
		return InboundNatRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *inboundNatRulePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *inboundNatRulePoller) pollUntilDone(ctx context.Context, freq time.Duration) (InboundNatRuleResponse, error) {
	respType := InboundNatRuleResponse{InboundNatRule: &InboundNatRule{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.InboundNatRule)
	if err != nil {
		return InboundNatRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// InboundSecurityRulePoller provides polling facilities until the operation reaches a terminal state.
type InboundSecurityRulePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final InboundSecurityRuleResponse will be returned.
	FinalResponse(ctx context.Context) (InboundSecurityRuleResponse, error)
}

type inboundSecurityRulePoller struct {
	pt *armcore.LROPoller
}

func (p *inboundSecurityRulePoller) Done() bool {
	return p.pt.Done()
}

func (p *inboundSecurityRulePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *inboundSecurityRulePoller) FinalResponse(ctx context.Context) (InboundSecurityRuleResponse, error) {
	respType := InboundSecurityRuleResponse{InboundSecurityRule: &InboundSecurityRule{}}
	resp, err := p.pt.FinalResponse(ctx, respType.InboundSecurityRule)
	if err != nil {
		return InboundSecurityRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *inboundSecurityRulePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *inboundSecurityRulePoller) pollUntilDone(ctx context.Context, freq time.Duration) (InboundSecurityRuleResponse, error) {
	respType := InboundSecurityRuleResponse{InboundSecurityRule: &InboundSecurityRule{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.InboundSecurityRule)
	if err != nil {
		return InboundSecurityRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// LoadBalancerPoller provides polling facilities until the operation reaches a terminal state.
type LoadBalancerPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final LoadBalancerResponse will be returned.
	FinalResponse(ctx context.Context) (LoadBalancerResponse, error)
}

type loadBalancerPoller struct {
	pt *armcore.LROPoller
}

func (p *loadBalancerPoller) Done() bool {
	return p.pt.Done()
}

func (p *loadBalancerPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *loadBalancerPoller) FinalResponse(ctx context.Context) (LoadBalancerResponse, error) {
	respType := LoadBalancerResponse{LoadBalancer: &LoadBalancer{}}
	resp, err := p.pt.FinalResponse(ctx, respType.LoadBalancer)
	if err != nil {
		return LoadBalancerResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *loadBalancerPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *loadBalancerPoller) pollUntilDone(ctx context.Context, freq time.Duration) (LoadBalancerResponse, error) {
	respType := LoadBalancerResponse{LoadBalancer: &LoadBalancer{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.LoadBalancer)
	if err != nil {
		return LoadBalancerResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// LocalNetworkGatewayPoller provides polling facilities until the operation reaches a terminal state.
type LocalNetworkGatewayPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final LocalNetworkGatewayResponse will be returned.
	FinalResponse(ctx context.Context) (LocalNetworkGatewayResponse, error)
}

type localNetworkGatewayPoller struct {
	pt *armcore.LROPoller
}

func (p *localNetworkGatewayPoller) Done() bool {
	return p.pt.Done()
}

func (p *localNetworkGatewayPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *localNetworkGatewayPoller) FinalResponse(ctx context.Context) (LocalNetworkGatewayResponse, error) {
	respType := LocalNetworkGatewayResponse{LocalNetworkGateway: &LocalNetworkGateway{}}
	resp, err := p.pt.FinalResponse(ctx, respType.LocalNetworkGateway)
	if err != nil {
		return LocalNetworkGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *localNetworkGatewayPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *localNetworkGatewayPoller) pollUntilDone(ctx context.Context, freq time.Duration) (LocalNetworkGatewayResponse, error) {
	respType := LocalNetworkGatewayResponse{LocalNetworkGateway: &LocalNetworkGateway{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.LocalNetworkGateway)
	if err != nil {
		return LocalNetworkGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// NatGatewayPoller provides polling facilities until the operation reaches a terminal state.
type NatGatewayPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final NatGatewayResponse will be returned.
	FinalResponse(ctx context.Context) (NatGatewayResponse, error)
}

type natGatewayPoller struct {
	pt *armcore.LROPoller
}

func (p *natGatewayPoller) Done() bool {
	return p.pt.Done()
}

func (p *natGatewayPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *natGatewayPoller) FinalResponse(ctx context.Context) (NatGatewayResponse, error) {
	respType := NatGatewayResponse{NatGateway: &NatGateway{}}
	resp, err := p.pt.FinalResponse(ctx, respType.NatGateway)
	if err != nil {
		return NatGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *natGatewayPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *natGatewayPoller) pollUntilDone(ctx context.Context, freq time.Duration) (NatGatewayResponse, error) {
	respType := NatGatewayResponse{NatGateway: &NatGateway{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.NatGateway)
	if err != nil {
		return NatGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// NetworkConfigurationDiagnosticResponsePoller provides polling facilities until the operation reaches a terminal state.
type NetworkConfigurationDiagnosticResponsePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final NetworkConfigurationDiagnosticResponseResponse will be returned.
	FinalResponse(ctx context.Context) (NetworkConfigurationDiagnosticResponseResponse, error)
}

type networkConfigurationDiagnosticResponsePoller struct {
	pt *armcore.LROPoller
}

func (p *networkConfigurationDiagnosticResponsePoller) Done() bool {
	return p.pt.Done()
}

func (p *networkConfigurationDiagnosticResponsePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *networkConfigurationDiagnosticResponsePoller) FinalResponse(ctx context.Context) (NetworkConfigurationDiagnosticResponseResponse, error) {
	respType := NetworkConfigurationDiagnosticResponseResponse{NetworkConfigurationDiagnosticResponse: &NetworkConfigurationDiagnosticResponse{}}
	resp, err := p.pt.FinalResponse(ctx, respType.NetworkConfigurationDiagnosticResponse)
	if err != nil {
		return NetworkConfigurationDiagnosticResponseResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *networkConfigurationDiagnosticResponsePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *networkConfigurationDiagnosticResponsePoller) pollUntilDone(ctx context.Context, freq time.Duration) (NetworkConfigurationDiagnosticResponseResponse, error) {
	respType := NetworkConfigurationDiagnosticResponseResponse{NetworkConfigurationDiagnosticResponse: &NetworkConfigurationDiagnosticResponse{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.NetworkConfigurationDiagnosticResponse)
	if err != nil {
		return NetworkConfigurationDiagnosticResponseResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// NetworkInterfacePoller provides polling facilities until the operation reaches a terminal state.
type NetworkInterfacePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final NetworkInterfaceResponse will be returned.
	FinalResponse(ctx context.Context) (NetworkInterfaceResponse, error)
}

type networkInterfacePoller struct {
	pt *armcore.LROPoller
}

func (p *networkInterfacePoller) Done() bool {
	return p.pt.Done()
}

func (p *networkInterfacePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *networkInterfacePoller) FinalResponse(ctx context.Context) (NetworkInterfaceResponse, error) {
	respType := NetworkInterfaceResponse{NetworkInterface: &NetworkInterface{}}
	resp, err := p.pt.FinalResponse(ctx, respType.NetworkInterface)
	if err != nil {
		return NetworkInterfaceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *networkInterfacePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *networkInterfacePoller) pollUntilDone(ctx context.Context, freq time.Duration) (NetworkInterfaceResponse, error) {
	respType := NetworkInterfaceResponse{NetworkInterface: &NetworkInterface{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.NetworkInterface)
	if err != nil {
		return NetworkInterfaceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// NetworkInterfaceTapConfigurationPoller provides polling facilities until the operation reaches a terminal state.
type NetworkInterfaceTapConfigurationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final NetworkInterfaceTapConfigurationResponse will be returned.
	FinalResponse(ctx context.Context) (NetworkInterfaceTapConfigurationResponse, error)
}

type networkInterfaceTapConfigurationPoller struct {
	pt *armcore.LROPoller
}

func (p *networkInterfaceTapConfigurationPoller) Done() bool {
	return p.pt.Done()
}

func (p *networkInterfaceTapConfigurationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *networkInterfaceTapConfigurationPoller) FinalResponse(ctx context.Context) (NetworkInterfaceTapConfigurationResponse, error) {
	respType := NetworkInterfaceTapConfigurationResponse{NetworkInterfaceTapConfiguration: &NetworkInterfaceTapConfiguration{}}
	resp, err := p.pt.FinalResponse(ctx, respType.NetworkInterfaceTapConfiguration)
	if err != nil {
		return NetworkInterfaceTapConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *networkInterfaceTapConfigurationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *networkInterfaceTapConfigurationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (NetworkInterfaceTapConfigurationResponse, error) {
	respType := NetworkInterfaceTapConfigurationResponse{NetworkInterfaceTapConfiguration: &NetworkInterfaceTapConfiguration{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.NetworkInterfaceTapConfiguration)
	if err != nil {
		return NetworkInterfaceTapConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// NetworkSecurityGroupPoller provides polling facilities until the operation reaches a terminal state.
type NetworkSecurityGroupPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final NetworkSecurityGroupResponse will be returned.
	FinalResponse(ctx context.Context) (NetworkSecurityGroupResponse, error)
}

type networkSecurityGroupPoller struct {
	pt *armcore.LROPoller
}

func (p *networkSecurityGroupPoller) Done() bool {
	return p.pt.Done()
}

func (p *networkSecurityGroupPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *networkSecurityGroupPoller) FinalResponse(ctx context.Context) (NetworkSecurityGroupResponse, error) {
	respType := NetworkSecurityGroupResponse{NetworkSecurityGroup: &NetworkSecurityGroup{}}
	resp, err := p.pt.FinalResponse(ctx, respType.NetworkSecurityGroup)
	if err != nil {
		return NetworkSecurityGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *networkSecurityGroupPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *networkSecurityGroupPoller) pollUntilDone(ctx context.Context, freq time.Duration) (NetworkSecurityGroupResponse, error) {
	respType := NetworkSecurityGroupResponse{NetworkSecurityGroup: &NetworkSecurityGroup{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.NetworkSecurityGroup)
	if err != nil {
		return NetworkSecurityGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// NetworkVirtualAppliancePoller provides polling facilities until the operation reaches a terminal state.
type NetworkVirtualAppliancePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final NetworkVirtualApplianceResponse will be returned.
	FinalResponse(ctx context.Context) (NetworkVirtualApplianceResponse, error)
}

type networkVirtualAppliancePoller struct {
	pt *armcore.LROPoller
}

func (p *networkVirtualAppliancePoller) Done() bool {
	return p.pt.Done()
}

func (p *networkVirtualAppliancePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *networkVirtualAppliancePoller) FinalResponse(ctx context.Context) (NetworkVirtualApplianceResponse, error) {
	respType := NetworkVirtualApplianceResponse{NetworkVirtualAppliance: &NetworkVirtualAppliance{}}
	resp, err := p.pt.FinalResponse(ctx, respType.NetworkVirtualAppliance)
	if err != nil {
		return NetworkVirtualApplianceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *networkVirtualAppliancePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *networkVirtualAppliancePoller) pollUntilDone(ctx context.Context, freq time.Duration) (NetworkVirtualApplianceResponse, error) {
	respType := NetworkVirtualApplianceResponse{NetworkVirtualAppliance: &NetworkVirtualAppliance{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.NetworkVirtualAppliance)
	if err != nil {
		return NetworkVirtualApplianceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// NextHopResultPoller provides polling facilities until the operation reaches a terminal state.
type NextHopResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final NextHopResultResponse will be returned.
	FinalResponse(ctx context.Context) (NextHopResultResponse, error)
}

type nextHopResultPoller struct {
	pt *armcore.LROPoller
}

func (p *nextHopResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *nextHopResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *nextHopResultPoller) FinalResponse(ctx context.Context) (NextHopResultResponse, error) {
	respType := NextHopResultResponse{NextHopResult: &NextHopResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.NextHopResult)
	if err != nil {
		return NextHopResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *nextHopResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *nextHopResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (NextHopResultResponse, error) {
	respType := NextHopResultResponse{NextHopResult: &NextHopResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.NextHopResult)
	if err != nil {
		return NextHopResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// P2SVPNConnectionHealthPoller provides polling facilities until the operation reaches a terminal state.
type P2SVPNConnectionHealthPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final P2SVPNConnectionHealthResponse will be returned.
	FinalResponse(ctx context.Context) (P2SVPNConnectionHealthResponse, error)
}

type p2SVPNConnectionHealthPoller struct {
	pt *armcore.LROPoller
}

func (p *p2SVPNConnectionHealthPoller) Done() bool {
	return p.pt.Done()
}

func (p *p2SVPNConnectionHealthPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *p2SVPNConnectionHealthPoller) FinalResponse(ctx context.Context) (P2SVPNConnectionHealthResponse, error) {
	respType := P2SVPNConnectionHealthResponse{P2SVPNConnectionHealth: &P2SVPNConnectionHealth{}}
	resp, err := p.pt.FinalResponse(ctx, respType.P2SVPNConnectionHealth)
	if err != nil {
		return P2SVPNConnectionHealthResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *p2SVPNConnectionHealthPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *p2SVPNConnectionHealthPoller) pollUntilDone(ctx context.Context, freq time.Duration) (P2SVPNConnectionHealthResponse, error) {
	respType := P2SVPNConnectionHealthResponse{P2SVPNConnectionHealth: &P2SVPNConnectionHealth{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.P2SVPNConnectionHealth)
	if err != nil {
		return P2SVPNConnectionHealthResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// P2SVPNGatewayPoller provides polling facilities until the operation reaches a terminal state.
type P2SVPNGatewayPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final P2SVPNGatewayResponse will be returned.
	FinalResponse(ctx context.Context) (P2SVPNGatewayResponse, error)
}

type p2SVPNGatewayPoller struct {
	pt *armcore.LROPoller
}

func (p *p2SVPNGatewayPoller) Done() bool {
	return p.pt.Done()
}

func (p *p2SVPNGatewayPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *p2SVPNGatewayPoller) FinalResponse(ctx context.Context) (P2SVPNGatewayResponse, error) {
	respType := P2SVPNGatewayResponse{P2SVPNGateway: &P2SVPNGateway{}}
	resp, err := p.pt.FinalResponse(ctx, respType.P2SVPNGateway)
	if err != nil {
		return P2SVPNGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *p2SVPNGatewayPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *p2SVPNGatewayPoller) pollUntilDone(ctx context.Context, freq time.Duration) (P2SVPNGatewayResponse, error) {
	respType := P2SVPNGatewayResponse{P2SVPNGateway: &P2SVPNGateway{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.P2SVPNGateway)
	if err != nil {
		return P2SVPNGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PacketCaptureQueryStatusResultPoller provides polling facilities until the operation reaches a terminal state.
type PacketCaptureQueryStatusResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PacketCaptureQueryStatusResultResponse will be returned.
	FinalResponse(ctx context.Context) (PacketCaptureQueryStatusResultResponse, error)
}

type packetCaptureQueryStatusResultPoller struct {
	pt *armcore.LROPoller
}

func (p *packetCaptureQueryStatusResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *packetCaptureQueryStatusResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *packetCaptureQueryStatusResultPoller) FinalResponse(ctx context.Context) (PacketCaptureQueryStatusResultResponse, error) {
	respType := PacketCaptureQueryStatusResultResponse{PacketCaptureQueryStatusResult: &PacketCaptureQueryStatusResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PacketCaptureQueryStatusResult)
	if err != nil {
		return PacketCaptureQueryStatusResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *packetCaptureQueryStatusResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *packetCaptureQueryStatusResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PacketCaptureQueryStatusResultResponse, error) {
	respType := PacketCaptureQueryStatusResultResponse{PacketCaptureQueryStatusResult: &PacketCaptureQueryStatusResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PacketCaptureQueryStatusResult)
	if err != nil {
		return PacketCaptureQueryStatusResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PacketCaptureResultPoller provides polling facilities until the operation reaches a terminal state.
type PacketCaptureResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PacketCaptureResultResponse will be returned.
	FinalResponse(ctx context.Context) (PacketCaptureResultResponse, error)
}

type packetCaptureResultPoller struct {
	pt *armcore.LROPoller
}

func (p *packetCaptureResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *packetCaptureResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *packetCaptureResultPoller) FinalResponse(ctx context.Context) (PacketCaptureResultResponse, error) {
	respType := PacketCaptureResultResponse{PacketCaptureResult: &PacketCaptureResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PacketCaptureResult)
	if err != nil {
		return PacketCaptureResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *packetCaptureResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *packetCaptureResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PacketCaptureResultResponse, error) {
	respType := PacketCaptureResultResponse{PacketCaptureResult: &PacketCaptureResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PacketCaptureResult)
	if err != nil {
		return PacketCaptureResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PeerRouteListPoller provides polling facilities until the operation reaches a terminal state.
type PeerRouteListPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PeerRouteListResponse will be returned.
	FinalResponse(ctx context.Context) (PeerRouteListResponse, error)
}

type peerRouteListPoller struct {
	pt *armcore.LROPoller
}

func (p *peerRouteListPoller) Done() bool {
	return p.pt.Done()
}

func (p *peerRouteListPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *peerRouteListPoller) FinalResponse(ctx context.Context) (PeerRouteListResponse, error) {
	respType := PeerRouteListResponse{PeerRouteList: &PeerRouteList{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PeerRouteList)
	if err != nil {
		return PeerRouteListResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *peerRouteListPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *peerRouteListPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PeerRouteListResponse, error) {
	respType := PeerRouteListResponse{PeerRouteList: &PeerRouteList{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PeerRouteList)
	if err != nil {
		return PeerRouteListResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PrivateDNSZoneGroupPoller provides polling facilities until the operation reaches a terminal state.
type PrivateDNSZoneGroupPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PrivateDNSZoneGroupResponse will be returned.
	FinalResponse(ctx context.Context) (PrivateDNSZoneGroupResponse, error)
}

type privateDNSZoneGroupPoller struct {
	pt *armcore.LROPoller
}

func (p *privateDNSZoneGroupPoller) Done() bool {
	return p.pt.Done()
}

func (p *privateDNSZoneGroupPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *privateDNSZoneGroupPoller) FinalResponse(ctx context.Context) (PrivateDNSZoneGroupResponse, error) {
	respType := PrivateDNSZoneGroupResponse{PrivateDNSZoneGroup: &PrivateDNSZoneGroup{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PrivateDNSZoneGroup)
	if err != nil {
		return PrivateDNSZoneGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *privateDNSZoneGroupPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *privateDNSZoneGroupPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PrivateDNSZoneGroupResponse, error) {
	respType := PrivateDNSZoneGroupResponse{PrivateDNSZoneGroup: &PrivateDNSZoneGroup{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PrivateDNSZoneGroup)
	if err != nil {
		return PrivateDNSZoneGroupResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PrivateEndpointPoller provides polling facilities until the operation reaches a terminal state.
type PrivateEndpointPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PrivateEndpointResponse will be returned.
	FinalResponse(ctx context.Context) (PrivateEndpointResponse, error)
}

type privateEndpointPoller struct {
	pt *armcore.LROPoller
}

func (p *privateEndpointPoller) Done() bool {
	return p.pt.Done()
}

func (p *privateEndpointPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *privateEndpointPoller) FinalResponse(ctx context.Context) (PrivateEndpointResponse, error) {
	respType := PrivateEndpointResponse{PrivateEndpoint: &PrivateEndpoint{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PrivateEndpoint)
	if err != nil {
		return PrivateEndpointResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *privateEndpointPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *privateEndpointPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PrivateEndpointResponse, error) {
	respType := PrivateEndpointResponse{PrivateEndpoint: &PrivateEndpoint{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PrivateEndpoint)
	if err != nil {
		return PrivateEndpointResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PrivateLinkServicePoller provides polling facilities until the operation reaches a terminal state.
type PrivateLinkServicePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PrivateLinkServiceResponse will be returned.
	FinalResponse(ctx context.Context) (PrivateLinkServiceResponse, error)
}

type privateLinkServicePoller struct {
	pt *armcore.LROPoller
}

func (p *privateLinkServicePoller) Done() bool {
	return p.pt.Done()
}

func (p *privateLinkServicePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *privateLinkServicePoller) FinalResponse(ctx context.Context) (PrivateLinkServiceResponse, error) {
	respType := PrivateLinkServiceResponse{PrivateLinkService: &PrivateLinkService{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PrivateLinkService)
	if err != nil {
		return PrivateLinkServiceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *privateLinkServicePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *privateLinkServicePoller) pollUntilDone(ctx context.Context, freq time.Duration) (PrivateLinkServiceResponse, error) {
	respType := PrivateLinkServiceResponse{PrivateLinkService: &PrivateLinkService{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PrivateLinkService)
	if err != nil {
		return PrivateLinkServiceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PrivateLinkServiceVisibilityPoller provides polling facilities until the operation reaches a terminal state.
type PrivateLinkServiceVisibilityPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PrivateLinkServiceVisibilityResponse will be returned.
	FinalResponse(ctx context.Context) (PrivateLinkServiceVisibilityResponse, error)
}

type privateLinkServiceVisibilityPoller struct {
	pt *armcore.LROPoller
}

func (p *privateLinkServiceVisibilityPoller) Done() bool {
	return p.pt.Done()
}

func (p *privateLinkServiceVisibilityPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *privateLinkServiceVisibilityPoller) FinalResponse(ctx context.Context) (PrivateLinkServiceVisibilityResponse, error) {
	respType := PrivateLinkServiceVisibilityResponse{PrivateLinkServiceVisibility: &PrivateLinkServiceVisibility{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PrivateLinkServiceVisibility)
	if err != nil {
		return PrivateLinkServiceVisibilityResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *privateLinkServiceVisibilityPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *privateLinkServiceVisibilityPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PrivateLinkServiceVisibilityResponse, error) {
	respType := PrivateLinkServiceVisibilityResponse{PrivateLinkServiceVisibility: &PrivateLinkServiceVisibility{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PrivateLinkServiceVisibility)
	if err != nil {
		return PrivateLinkServiceVisibilityResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PublicIPAddressPoller provides polling facilities until the operation reaches a terminal state.
type PublicIPAddressPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PublicIPAddressResponse will be returned.
	FinalResponse(ctx context.Context) (PublicIPAddressResponse, error)
}

type publicIPAddressPoller struct {
	pt *armcore.LROPoller
}

func (p *publicIPAddressPoller) Done() bool {
	return p.pt.Done()
}

func (p *publicIPAddressPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *publicIPAddressPoller) FinalResponse(ctx context.Context) (PublicIPAddressResponse, error) {
	respType := PublicIPAddressResponse{PublicIPAddress: &PublicIPAddress{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PublicIPAddress)
	if err != nil {
		return PublicIPAddressResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *publicIPAddressPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *publicIPAddressPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PublicIPAddressResponse, error) {
	respType := PublicIPAddressResponse{PublicIPAddress: &PublicIPAddress{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PublicIPAddress)
	if err != nil {
		return PublicIPAddressResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PublicIPPrefixPoller provides polling facilities until the operation reaches a terminal state.
type PublicIPPrefixPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final PublicIPPrefixResponse will be returned.
	FinalResponse(ctx context.Context) (PublicIPPrefixResponse, error)
}

type publicIPPrefixPoller struct {
	pt *armcore.LROPoller
}

func (p *publicIPPrefixPoller) Done() bool {
	return p.pt.Done()
}

func (p *publicIPPrefixPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *publicIPPrefixPoller) FinalResponse(ctx context.Context) (PublicIPPrefixResponse, error) {
	respType := PublicIPPrefixResponse{PublicIPPrefix: &PublicIPPrefix{}}
	resp, err := p.pt.FinalResponse(ctx, respType.PublicIPPrefix)
	if err != nil {
		return PublicIPPrefixResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *publicIPPrefixPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *publicIPPrefixPoller) pollUntilDone(ctx context.Context, freq time.Duration) (PublicIPPrefixResponse, error) {
	respType := PublicIPPrefixResponse{PublicIPPrefix: &PublicIPPrefix{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.PublicIPPrefix)
	if err != nil {
		return PublicIPPrefixResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// RouteFilterPoller provides polling facilities until the operation reaches a terminal state.
type RouteFilterPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final RouteFilterResponse will be returned.
	FinalResponse(ctx context.Context) (RouteFilterResponse, error)
}

type routeFilterPoller struct {
	pt *armcore.LROPoller
}

func (p *routeFilterPoller) Done() bool {
	return p.pt.Done()
}

func (p *routeFilterPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *routeFilterPoller) FinalResponse(ctx context.Context) (RouteFilterResponse, error) {
	respType := RouteFilterResponse{RouteFilter: &RouteFilter{}}
	resp, err := p.pt.FinalResponse(ctx, respType.RouteFilter)
	if err != nil {
		return RouteFilterResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *routeFilterPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *routeFilterPoller) pollUntilDone(ctx context.Context, freq time.Duration) (RouteFilterResponse, error) {
	respType := RouteFilterResponse{RouteFilter: &RouteFilter{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.RouteFilter)
	if err != nil {
		return RouteFilterResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// RouteFilterRulePoller provides polling facilities until the operation reaches a terminal state.
type RouteFilterRulePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final RouteFilterRuleResponse will be returned.
	FinalResponse(ctx context.Context) (RouteFilterRuleResponse, error)
}

type routeFilterRulePoller struct {
	pt *armcore.LROPoller
}

func (p *routeFilterRulePoller) Done() bool {
	return p.pt.Done()
}

func (p *routeFilterRulePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *routeFilterRulePoller) FinalResponse(ctx context.Context) (RouteFilterRuleResponse, error) {
	respType := RouteFilterRuleResponse{RouteFilterRule: &RouteFilterRule{}}
	resp, err := p.pt.FinalResponse(ctx, respType.RouteFilterRule)
	if err != nil {
		return RouteFilterRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *routeFilterRulePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *routeFilterRulePoller) pollUntilDone(ctx context.Context, freq time.Duration) (RouteFilterRuleResponse, error) {
	respType := RouteFilterRuleResponse{RouteFilterRule: &RouteFilterRule{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.RouteFilterRule)
	if err != nil {
		return RouteFilterRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// RoutePoller provides polling facilities until the operation reaches a terminal state.
type RoutePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final RouteResponse will be returned.
	FinalResponse(ctx context.Context) (RouteResponse, error)
}

type routePoller struct {
	pt *armcore.LROPoller
}

func (p *routePoller) Done() bool {
	return p.pt.Done()
}

func (p *routePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *routePoller) FinalResponse(ctx context.Context) (RouteResponse, error) {
	respType := RouteResponse{Route: &Route{}}
	resp, err := p.pt.FinalResponse(ctx, respType.Route)
	if err != nil {
		return RouteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *routePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *routePoller) pollUntilDone(ctx context.Context, freq time.Duration) (RouteResponse, error) {
	respType := RouteResponse{Route: &Route{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.Route)
	if err != nil {
		return RouteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// RouteTablePoller provides polling facilities until the operation reaches a terminal state.
type RouteTablePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final RouteTableResponse will be returned.
	FinalResponse(ctx context.Context) (RouteTableResponse, error)
}

type routeTablePoller struct {
	pt *armcore.LROPoller
}

func (p *routeTablePoller) Done() bool {
	return p.pt.Done()
}

func (p *routeTablePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *routeTablePoller) FinalResponse(ctx context.Context) (RouteTableResponse, error) {
	respType := RouteTableResponse{RouteTable: &RouteTable{}}
	resp, err := p.pt.FinalResponse(ctx, respType.RouteTable)
	if err != nil {
		return RouteTableResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *routeTablePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *routeTablePoller) pollUntilDone(ctx context.Context, freq time.Duration) (RouteTableResponse, error) {
	respType := RouteTableResponse{RouteTable: &RouteTable{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.RouteTable)
	if err != nil {
		return RouteTableResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// SecurityGroupViewResultPoller provides polling facilities until the operation reaches a terminal state.
type SecurityGroupViewResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final SecurityGroupViewResultResponse will be returned.
	FinalResponse(ctx context.Context) (SecurityGroupViewResultResponse, error)
}

type securityGroupViewResultPoller struct {
	pt *armcore.LROPoller
}

func (p *securityGroupViewResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *securityGroupViewResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *securityGroupViewResultPoller) FinalResponse(ctx context.Context) (SecurityGroupViewResultResponse, error) {
	respType := SecurityGroupViewResultResponse{SecurityGroupViewResult: &SecurityGroupViewResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.SecurityGroupViewResult)
	if err != nil {
		return SecurityGroupViewResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *securityGroupViewResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *securityGroupViewResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (SecurityGroupViewResultResponse, error) {
	respType := SecurityGroupViewResultResponse{SecurityGroupViewResult: &SecurityGroupViewResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.SecurityGroupViewResult)
	if err != nil {
		return SecurityGroupViewResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// SecurityPartnerProviderPoller provides polling facilities until the operation reaches a terminal state.
type SecurityPartnerProviderPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final SecurityPartnerProviderResponse will be returned.
	FinalResponse(ctx context.Context) (SecurityPartnerProviderResponse, error)
}

type securityPartnerProviderPoller struct {
	pt *armcore.LROPoller
}

func (p *securityPartnerProviderPoller) Done() bool {
	return p.pt.Done()
}

func (p *securityPartnerProviderPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *securityPartnerProviderPoller) FinalResponse(ctx context.Context) (SecurityPartnerProviderResponse, error) {
	respType := SecurityPartnerProviderResponse{SecurityPartnerProvider: &SecurityPartnerProvider{}}
	resp, err := p.pt.FinalResponse(ctx, respType.SecurityPartnerProvider)
	if err != nil {
		return SecurityPartnerProviderResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *securityPartnerProviderPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *securityPartnerProviderPoller) pollUntilDone(ctx context.Context, freq time.Duration) (SecurityPartnerProviderResponse, error) {
	respType := SecurityPartnerProviderResponse{SecurityPartnerProvider: &SecurityPartnerProvider{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.SecurityPartnerProvider)
	if err != nil {
		return SecurityPartnerProviderResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// SecurityRulePoller provides polling facilities until the operation reaches a terminal state.
type SecurityRulePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final SecurityRuleResponse will be returned.
	FinalResponse(ctx context.Context) (SecurityRuleResponse, error)
}

type securityRulePoller struct {
	pt *armcore.LROPoller
}

func (p *securityRulePoller) Done() bool {
	return p.pt.Done()
}

func (p *securityRulePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *securityRulePoller) FinalResponse(ctx context.Context) (SecurityRuleResponse, error) {
	respType := SecurityRuleResponse{SecurityRule: &SecurityRule{}}
	resp, err := p.pt.FinalResponse(ctx, respType.SecurityRule)
	if err != nil {
		return SecurityRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *securityRulePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *securityRulePoller) pollUntilDone(ctx context.Context, freq time.Duration) (SecurityRuleResponse, error) {
	respType := SecurityRuleResponse{SecurityRule: &SecurityRule{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.SecurityRule)
	if err != nil {
		return SecurityRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ServiceEndpointPolicyDefinitionPoller provides polling facilities until the operation reaches a terminal state.
type ServiceEndpointPolicyDefinitionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ServiceEndpointPolicyDefinitionResponse will be returned.
	FinalResponse(ctx context.Context) (ServiceEndpointPolicyDefinitionResponse, error)
}

type serviceEndpointPolicyDefinitionPoller struct {
	pt *armcore.LROPoller
}

func (p *serviceEndpointPolicyDefinitionPoller) Done() bool {
	return p.pt.Done()
}

func (p *serviceEndpointPolicyDefinitionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *serviceEndpointPolicyDefinitionPoller) FinalResponse(ctx context.Context) (ServiceEndpointPolicyDefinitionResponse, error) {
	respType := ServiceEndpointPolicyDefinitionResponse{ServiceEndpointPolicyDefinition: &ServiceEndpointPolicyDefinition{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ServiceEndpointPolicyDefinition)
	if err != nil {
		return ServiceEndpointPolicyDefinitionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *serviceEndpointPolicyDefinitionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *serviceEndpointPolicyDefinitionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ServiceEndpointPolicyDefinitionResponse, error) {
	respType := ServiceEndpointPolicyDefinitionResponse{ServiceEndpointPolicyDefinition: &ServiceEndpointPolicyDefinition{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ServiceEndpointPolicyDefinition)
	if err != nil {
		return ServiceEndpointPolicyDefinitionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ServiceEndpointPolicyPoller provides polling facilities until the operation reaches a terminal state.
type ServiceEndpointPolicyPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final ServiceEndpointPolicyResponse will be returned.
	FinalResponse(ctx context.Context) (ServiceEndpointPolicyResponse, error)
}

type serviceEndpointPolicyPoller struct {
	pt *armcore.LROPoller
}

func (p *serviceEndpointPolicyPoller) Done() bool {
	return p.pt.Done()
}

func (p *serviceEndpointPolicyPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *serviceEndpointPolicyPoller) FinalResponse(ctx context.Context) (ServiceEndpointPolicyResponse, error) {
	respType := ServiceEndpointPolicyResponse{ServiceEndpointPolicy: &ServiceEndpointPolicy{}}
	resp, err := p.pt.FinalResponse(ctx, respType.ServiceEndpointPolicy)
	if err != nil {
		return ServiceEndpointPolicyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *serviceEndpointPolicyPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *serviceEndpointPolicyPoller) pollUntilDone(ctx context.Context, freq time.Duration) (ServiceEndpointPolicyResponse, error) {
	respType := ServiceEndpointPolicyResponse{ServiceEndpointPolicy: &ServiceEndpointPolicy{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.ServiceEndpointPolicy)
	if err != nil {
		return ServiceEndpointPolicyResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// StringPoller provides polling facilities until the operation reaches a terminal state.
type StringPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final StringResponse will be returned.
	FinalResponse(ctx context.Context) (StringResponse, error)
}

type stringPoller struct {
	pt *armcore.LROPoller
}

func (p *stringPoller) Done() bool {
	return p.pt.Done()
}

func (p *stringPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *stringPoller) FinalResponse(ctx context.Context) (StringResponse, error) {
	respType := StringResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.Value)
	if err != nil {
		return StringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *stringPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *stringPoller) pollUntilDone(ctx context.Context, freq time.Duration) (StringResponse, error) {
	respType := StringResponse{}
	resp, err := p.pt.PollUntilDone(ctx, freq, &respType.Value)
	if err != nil {
		return StringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// SubnetPoller provides polling facilities until the operation reaches a terminal state.
type SubnetPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final SubnetResponse will be returned.
	FinalResponse(ctx context.Context) (SubnetResponse, error)
}

type subnetPoller struct {
	pt *armcore.LROPoller
}

func (p *subnetPoller) Done() bool {
	return p.pt.Done()
}

func (p *subnetPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *subnetPoller) FinalResponse(ctx context.Context) (SubnetResponse, error) {
	respType := SubnetResponse{Subnet: &Subnet{}}
	resp, err := p.pt.FinalResponse(ctx, respType.Subnet)
	if err != nil {
		return SubnetResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *subnetPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *subnetPoller) pollUntilDone(ctx context.Context, freq time.Duration) (SubnetResponse, error) {
	respType := SubnetResponse{Subnet: &Subnet{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.Subnet)
	if err != nil {
		return SubnetResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// TroubleshootingResultPoller provides polling facilities until the operation reaches a terminal state.
type TroubleshootingResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final TroubleshootingResultResponse will be returned.
	FinalResponse(ctx context.Context) (TroubleshootingResultResponse, error)
}

type troubleshootingResultPoller struct {
	pt *armcore.LROPoller
}

func (p *troubleshootingResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *troubleshootingResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *troubleshootingResultPoller) FinalResponse(ctx context.Context) (TroubleshootingResultResponse, error) {
	respType := TroubleshootingResultResponse{TroubleshootingResult: &TroubleshootingResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.TroubleshootingResult)
	if err != nil {
		return TroubleshootingResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *troubleshootingResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *troubleshootingResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (TroubleshootingResultResponse, error) {
	respType := TroubleshootingResultResponse{TroubleshootingResult: &TroubleshootingResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.TroubleshootingResult)
	if err != nil {
		return TroubleshootingResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNClientConnectionHealthDetailListResultPoller provides polling facilities until the operation reaches a terminal state.
type VPNClientConnectionHealthDetailListResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNClientConnectionHealthDetailListResultResponse will be returned.
	FinalResponse(ctx context.Context) (VPNClientConnectionHealthDetailListResultResponse, error)
}

type vpnClientConnectionHealthDetailListResultPoller struct {
	pt *armcore.LROPoller
}

func (p *vpnClientConnectionHealthDetailListResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnClientConnectionHealthDetailListResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnClientConnectionHealthDetailListResultPoller) FinalResponse(ctx context.Context) (VPNClientConnectionHealthDetailListResultResponse, error) {
	respType := VPNClientConnectionHealthDetailListResultResponse{VPNClientConnectionHealthDetailListResult: &VPNClientConnectionHealthDetailListResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNClientConnectionHealthDetailListResult)
	if err != nil {
		return VPNClientConnectionHealthDetailListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnClientConnectionHealthDetailListResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnClientConnectionHealthDetailListResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNClientConnectionHealthDetailListResultResponse, error) {
	respType := VPNClientConnectionHealthDetailListResultResponse{VPNClientConnectionHealthDetailListResult: &VPNClientConnectionHealthDetailListResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNClientConnectionHealthDetailListResult)
	if err != nil {
		return VPNClientConnectionHealthDetailListResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNClientIPsecParametersPoller provides polling facilities until the operation reaches a terminal state.
type VPNClientIPsecParametersPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNClientIPsecParametersResponse will be returned.
	FinalResponse(ctx context.Context) (VPNClientIPsecParametersResponse, error)
}

type vpnClientIPSecParametersPoller struct {
	pt *armcore.LROPoller
}

func (p *vpnClientIPSecParametersPoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnClientIPSecParametersPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnClientIPSecParametersPoller) FinalResponse(ctx context.Context) (VPNClientIPsecParametersResponse, error) {
	respType := VPNClientIPsecParametersResponse{VPNClientIPsecParameters: &VPNClientIPsecParameters{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNClientIPsecParameters)
	if err != nil {
		return VPNClientIPsecParametersResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnClientIPSecParametersPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnClientIPSecParametersPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNClientIPsecParametersResponse, error) {
	respType := VPNClientIPsecParametersResponse{VPNClientIPsecParameters: &VPNClientIPsecParameters{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNClientIPsecParameters)
	if err != nil {
		return VPNClientIPsecParametersResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNConnectionPoller provides polling facilities until the operation reaches a terminal state.
type VPNConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (VPNConnectionResponse, error)
}

type vpnConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *vpnConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnConnectionPoller) FinalResponse(ctx context.Context) (VPNConnectionResponse, error) {
	respType := VPNConnectionResponse{VPNConnection: &VPNConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNConnection)
	if err != nil {
		return VPNConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNConnectionResponse, error) {
	respType := VPNConnectionResponse{VPNConnection: &VPNConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNConnection)
	if err != nil {
		return VPNConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNGatewayNatRulePoller provides polling facilities until the operation reaches a terminal state.
type VPNGatewayNatRulePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNGatewayNatRuleResponse will be returned.
	FinalResponse(ctx context.Context) (VPNGatewayNatRuleResponse, error)
}

type vpnGatewayNatRulePoller struct {
	pt *armcore.LROPoller
}

func (p *vpnGatewayNatRulePoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnGatewayNatRulePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnGatewayNatRulePoller) FinalResponse(ctx context.Context) (VPNGatewayNatRuleResponse, error) {
	respType := VPNGatewayNatRuleResponse{VPNGatewayNatRule: &VPNGatewayNatRule{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNGatewayNatRule)
	if err != nil {
		return VPNGatewayNatRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnGatewayNatRulePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnGatewayNatRulePoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNGatewayNatRuleResponse, error) {
	respType := VPNGatewayNatRuleResponse{VPNGatewayNatRule: &VPNGatewayNatRule{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNGatewayNatRule)
	if err != nil {
		return VPNGatewayNatRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNGatewayPoller provides polling facilities until the operation reaches a terminal state.
type VPNGatewayPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNGatewayResponse will be returned.
	FinalResponse(ctx context.Context) (VPNGatewayResponse, error)
}

type vpnGatewayPoller struct {
	pt *armcore.LROPoller
}

func (p *vpnGatewayPoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnGatewayPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnGatewayPoller) FinalResponse(ctx context.Context) (VPNGatewayResponse, error) {
	respType := VPNGatewayResponse{VPNGateway: &VPNGateway{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNGateway)
	if err != nil {
		return VPNGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnGatewayPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnGatewayPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNGatewayResponse, error) {
	respType := VPNGatewayResponse{VPNGateway: &VPNGateway{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNGateway)
	if err != nil {
		return VPNGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNProfileResponsePoller provides polling facilities until the operation reaches a terminal state.
type VPNProfileResponsePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNProfileResponseResponse will be returned.
	FinalResponse(ctx context.Context) (VPNProfileResponseResponse, error)
}

type vpnProfileResponsePoller struct {
	pt *armcore.LROPoller
}

func (p *vpnProfileResponsePoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnProfileResponsePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnProfileResponsePoller) FinalResponse(ctx context.Context) (VPNProfileResponseResponse, error) {
	respType := VPNProfileResponseResponse{VPNProfileResponse: &VPNProfileResponse{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNProfileResponse)
	if err != nil {
		return VPNProfileResponseResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnProfileResponsePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnProfileResponsePoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNProfileResponseResponse, error) {
	respType := VPNProfileResponseResponse{VPNProfileResponse: &VPNProfileResponse{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNProfileResponse)
	if err != nil {
		return VPNProfileResponseResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNServerConfigurationPoller provides polling facilities until the operation reaches a terminal state.
type VPNServerConfigurationPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNServerConfigurationResponse will be returned.
	FinalResponse(ctx context.Context) (VPNServerConfigurationResponse, error)
}

type vpnServerConfigurationPoller struct {
	pt *armcore.LROPoller
}

func (p *vpnServerConfigurationPoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnServerConfigurationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnServerConfigurationPoller) FinalResponse(ctx context.Context) (VPNServerConfigurationResponse, error) {
	respType := VPNServerConfigurationResponse{VPNServerConfiguration: &VPNServerConfiguration{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNServerConfiguration)
	if err != nil {
		return VPNServerConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnServerConfigurationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnServerConfigurationPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNServerConfigurationResponse, error) {
	respType := VPNServerConfigurationResponse{VPNServerConfiguration: &VPNServerConfiguration{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNServerConfiguration)
	if err != nil {
		return VPNServerConfigurationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNServerConfigurationsResponsePoller provides polling facilities until the operation reaches a terminal state.
type VPNServerConfigurationsResponsePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNServerConfigurationsResponseResponse will be returned.
	FinalResponse(ctx context.Context) (VPNServerConfigurationsResponseResponse, error)
}

type vpnServerConfigurationsResponsePoller struct {
	pt *armcore.LROPoller
}

func (p *vpnServerConfigurationsResponsePoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnServerConfigurationsResponsePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnServerConfigurationsResponsePoller) FinalResponse(ctx context.Context) (VPNServerConfigurationsResponseResponse, error) {
	respType := VPNServerConfigurationsResponseResponse{VPNServerConfigurationsResponse: &VPNServerConfigurationsResponse{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNServerConfigurationsResponse)
	if err != nil {
		return VPNServerConfigurationsResponseResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnServerConfigurationsResponsePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnServerConfigurationsResponsePoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNServerConfigurationsResponseResponse, error) {
	respType := VPNServerConfigurationsResponseResponse{VPNServerConfigurationsResponse: &VPNServerConfigurationsResponse{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNServerConfigurationsResponse)
	if err != nil {
		return VPNServerConfigurationsResponseResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VPNSitePoller provides polling facilities until the operation reaches a terminal state.
type VPNSitePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VPNSiteResponse will be returned.
	FinalResponse(ctx context.Context) (VPNSiteResponse, error)
}

type vpnSitePoller struct {
	pt *armcore.LROPoller
}

func (p *vpnSitePoller) Done() bool {
	return p.pt.Done()
}

func (p *vpnSitePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *vpnSitePoller) FinalResponse(ctx context.Context) (VPNSiteResponse, error) {
	respType := VPNSiteResponse{VPNSite: &VPNSite{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VPNSite)
	if err != nil {
		return VPNSiteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *vpnSitePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *vpnSitePoller) pollUntilDone(ctx context.Context, freq time.Duration) (VPNSiteResponse, error) {
	respType := VPNSiteResponse{VPNSite: &VPNSite{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VPNSite)
	if err != nil {
		return VPNSiteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VerificationIPFlowResultPoller provides polling facilities until the operation reaches a terminal state.
type VerificationIPFlowResultPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VerificationIPFlowResultResponse will be returned.
	FinalResponse(ctx context.Context) (VerificationIPFlowResultResponse, error)
}

type verificationIPFlowResultPoller struct {
	pt *armcore.LROPoller
}

func (p *verificationIPFlowResultPoller) Done() bool {
	return p.pt.Done()
}

func (p *verificationIPFlowResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *verificationIPFlowResultPoller) FinalResponse(ctx context.Context) (VerificationIPFlowResultResponse, error) {
	respType := VerificationIPFlowResultResponse{VerificationIPFlowResult: &VerificationIPFlowResult{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VerificationIPFlowResult)
	if err != nil {
		return VerificationIPFlowResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *verificationIPFlowResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *verificationIPFlowResultPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VerificationIPFlowResultResponse, error) {
	respType := VerificationIPFlowResultResponse{VerificationIPFlowResult: &VerificationIPFlowResult{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VerificationIPFlowResult)
	if err != nil {
		return VerificationIPFlowResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualApplianceSitePoller provides polling facilities until the operation reaches a terminal state.
type VirtualApplianceSitePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualApplianceSiteResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualApplianceSiteResponse, error)
}

type virtualApplianceSitePoller struct {
	pt *armcore.LROPoller
}

func (p *virtualApplianceSitePoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualApplianceSitePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualApplianceSitePoller) FinalResponse(ctx context.Context) (VirtualApplianceSiteResponse, error) {
	respType := VirtualApplianceSiteResponse{VirtualApplianceSite: &VirtualApplianceSite{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualApplianceSite)
	if err != nil {
		return VirtualApplianceSiteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualApplianceSitePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualApplianceSitePoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualApplianceSiteResponse, error) {
	respType := VirtualApplianceSiteResponse{VirtualApplianceSite: &VirtualApplianceSite{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualApplianceSite)
	if err != nil {
		return VirtualApplianceSiteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualHubPoller provides polling facilities until the operation reaches a terminal state.
type VirtualHubPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualHubResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualHubResponse, error)
}

type virtualHubPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualHubPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualHubPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualHubPoller) FinalResponse(ctx context.Context) (VirtualHubResponse, error) {
	respType := VirtualHubResponse{VirtualHub: &VirtualHub{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualHub)
	if err != nil {
		return VirtualHubResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualHubPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualHubPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualHubResponse, error) {
	respType := VirtualHubResponse{VirtualHub: &VirtualHub{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualHub)
	if err != nil {
		return VirtualHubResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualHubRouteTableV2Poller provides polling facilities until the operation reaches a terminal state.
type VirtualHubRouteTableV2Poller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualHubRouteTableV2Response will be returned.
	FinalResponse(ctx context.Context) (VirtualHubRouteTableV2Response, error)
}

type virtualHubRouteTableV2Poller struct {
	pt *armcore.LROPoller
}

func (p *virtualHubRouteTableV2Poller) Done() bool {
	return p.pt.Done()
}

func (p *virtualHubRouteTableV2Poller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualHubRouteTableV2Poller) FinalResponse(ctx context.Context) (VirtualHubRouteTableV2Response, error) {
	respType := VirtualHubRouteTableV2Response{VirtualHubRouteTableV2: &VirtualHubRouteTableV2{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualHubRouteTableV2)
	if err != nil {
		return VirtualHubRouteTableV2Response{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualHubRouteTableV2Poller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualHubRouteTableV2Poller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualHubRouteTableV2Response, error) {
	respType := VirtualHubRouteTableV2Response{VirtualHubRouteTableV2: &VirtualHubRouteTableV2{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualHubRouteTableV2)
	if err != nil {
		return VirtualHubRouteTableV2Response{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualNetworkGatewayConnectionPoller provides polling facilities until the operation reaches a terminal state.
type VirtualNetworkGatewayConnectionPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualNetworkGatewayConnectionResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualNetworkGatewayConnectionResponse, error)
}

type virtualNetworkGatewayConnectionPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualNetworkGatewayConnectionPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualNetworkGatewayConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualNetworkGatewayConnectionPoller) FinalResponse(ctx context.Context) (VirtualNetworkGatewayConnectionResponse, error) {
	respType := VirtualNetworkGatewayConnectionResponse{VirtualNetworkGatewayConnection: &VirtualNetworkGatewayConnection{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualNetworkGatewayConnection)
	if err != nil {
		return VirtualNetworkGatewayConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualNetworkGatewayConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualNetworkGatewayConnectionPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualNetworkGatewayConnectionResponse, error) {
	respType := VirtualNetworkGatewayConnectionResponse{VirtualNetworkGatewayConnection: &VirtualNetworkGatewayConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualNetworkGatewayConnection)
	if err != nil {
		return VirtualNetworkGatewayConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualNetworkGatewayNatRulePoller provides polling facilities until the operation reaches a terminal state.
type VirtualNetworkGatewayNatRulePoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualNetworkGatewayNatRuleResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualNetworkGatewayNatRuleResponse, error)
}

type virtualNetworkGatewayNatRulePoller struct {
	pt *armcore.LROPoller
}

func (p *virtualNetworkGatewayNatRulePoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualNetworkGatewayNatRulePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualNetworkGatewayNatRulePoller) FinalResponse(ctx context.Context) (VirtualNetworkGatewayNatRuleResponse, error) {
	respType := VirtualNetworkGatewayNatRuleResponse{VirtualNetworkGatewayNatRule: &VirtualNetworkGatewayNatRule{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualNetworkGatewayNatRule)
	if err != nil {
		return VirtualNetworkGatewayNatRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualNetworkGatewayNatRulePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualNetworkGatewayNatRulePoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualNetworkGatewayNatRuleResponse, error) {
	respType := VirtualNetworkGatewayNatRuleResponse{VirtualNetworkGatewayNatRule: &VirtualNetworkGatewayNatRule{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualNetworkGatewayNatRule)
	if err != nil {
		return VirtualNetworkGatewayNatRuleResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualNetworkGatewayPoller provides polling facilities until the operation reaches a terminal state.
type VirtualNetworkGatewayPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualNetworkGatewayResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualNetworkGatewayResponse, error)
}

type virtualNetworkGatewayPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualNetworkGatewayPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualNetworkGatewayPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualNetworkGatewayPoller) FinalResponse(ctx context.Context) (VirtualNetworkGatewayResponse, error) {
	respType := VirtualNetworkGatewayResponse{VirtualNetworkGateway: &VirtualNetworkGateway{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualNetworkGateway)
	if err != nil {
		return VirtualNetworkGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualNetworkGatewayPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualNetworkGatewayPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualNetworkGatewayResponse, error) {
	respType := VirtualNetworkGatewayResponse{VirtualNetworkGateway: &VirtualNetworkGateway{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualNetworkGateway)
	if err != nil {
		return VirtualNetworkGatewayResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualNetworkPeeringPoller provides polling facilities until the operation reaches a terminal state.
type VirtualNetworkPeeringPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualNetworkPeeringResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualNetworkPeeringResponse, error)
}

type virtualNetworkPeeringPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualNetworkPeeringPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualNetworkPeeringPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualNetworkPeeringPoller) FinalResponse(ctx context.Context) (VirtualNetworkPeeringResponse, error) {
	respType := VirtualNetworkPeeringResponse{VirtualNetworkPeering: &VirtualNetworkPeering{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualNetworkPeering)
	if err != nil {
		return VirtualNetworkPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualNetworkPeeringPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualNetworkPeeringPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualNetworkPeeringResponse, error) {
	respType := VirtualNetworkPeeringResponse{VirtualNetworkPeering: &VirtualNetworkPeering{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualNetworkPeering)
	if err != nil {
		return VirtualNetworkPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualNetworkPoller provides polling facilities until the operation reaches a terminal state.
type VirtualNetworkPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualNetworkResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualNetworkResponse, error)
}

type virtualNetworkPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualNetworkPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualNetworkPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualNetworkPoller) FinalResponse(ctx context.Context) (VirtualNetworkResponse, error) {
	respType := VirtualNetworkResponse{VirtualNetwork: &VirtualNetwork{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualNetwork)
	if err != nil {
		return VirtualNetworkResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualNetworkPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualNetworkPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualNetworkResponse, error) {
	respType := VirtualNetworkResponse{VirtualNetwork: &VirtualNetwork{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualNetwork)
	if err != nil {
		return VirtualNetworkResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualNetworkTapPoller provides polling facilities until the operation reaches a terminal state.
type VirtualNetworkTapPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualNetworkTapResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualNetworkTapResponse, error)
}

type virtualNetworkTapPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualNetworkTapPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualNetworkTapPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualNetworkTapPoller) FinalResponse(ctx context.Context) (VirtualNetworkTapResponse, error) {
	respType := VirtualNetworkTapResponse{VirtualNetworkTap: &VirtualNetworkTap{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualNetworkTap)
	if err != nil {
		return VirtualNetworkTapResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualNetworkTapPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualNetworkTapPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualNetworkTapResponse, error) {
	respType := VirtualNetworkTapResponse{VirtualNetworkTap: &VirtualNetworkTap{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualNetworkTap)
	if err != nil {
		return VirtualNetworkTapResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualRouterPeeringPoller provides polling facilities until the operation reaches a terminal state.
type VirtualRouterPeeringPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualRouterPeeringResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualRouterPeeringResponse, error)
}

type virtualRouterPeeringPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualRouterPeeringPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualRouterPeeringPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualRouterPeeringPoller) FinalResponse(ctx context.Context) (VirtualRouterPeeringResponse, error) {
	respType := VirtualRouterPeeringResponse{VirtualRouterPeering: &VirtualRouterPeering{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualRouterPeering)
	if err != nil {
		return VirtualRouterPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualRouterPeeringPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualRouterPeeringPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualRouterPeeringResponse, error) {
	respType := VirtualRouterPeeringResponse{VirtualRouterPeering: &VirtualRouterPeering{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualRouterPeering)
	if err != nil {
		return VirtualRouterPeeringResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualRouterPoller provides polling facilities until the operation reaches a terminal state.
type VirtualRouterPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualRouterResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualRouterResponse, error)
}

type virtualRouterPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualRouterPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualRouterPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualRouterPoller) FinalResponse(ctx context.Context) (VirtualRouterResponse, error) {
	respType := VirtualRouterResponse{VirtualRouter: &VirtualRouter{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualRouter)
	if err != nil {
		return VirtualRouterResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualRouterPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualRouterPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualRouterResponse, error) {
	respType := VirtualRouterResponse{VirtualRouter: &VirtualRouter{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualRouter)
	if err != nil {
		return VirtualRouterResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualWANPoller provides polling facilities until the operation reaches a terminal state.
type VirtualWANPoller interface {
	azcore.Poller
	// FinalResponse performs a final GET to the service and returns the final response
	// for the polling operation. If there is an error performing the final GET then an error is returned.
	// If the final GET succeeded then the final VirtualWANResponse will be returned.
	FinalResponse(ctx context.Context) (VirtualWANResponse, error)
}

type virtualWANPoller struct {
	pt *armcore.LROPoller
}

func (p *virtualWANPoller) Done() bool {
	return p.pt.Done()
}

func (p *virtualWANPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

func (p *virtualWANPoller) FinalResponse(ctx context.Context) (VirtualWANResponse, error) {
	respType := VirtualWANResponse{VirtualWAN: &VirtualWAN{}}
	resp, err := p.pt.FinalResponse(ctx, respType.VirtualWAN)
	if err != nil {
		return VirtualWANResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

func (p *virtualWANPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualWANPoller) pollUntilDone(ctx context.Context, freq time.Duration) (VirtualWANResponse, error) {
	respType := VirtualWANResponse{VirtualWAN: &VirtualWAN{}}
	resp, err := p.pt.PollUntilDone(ctx, freq, respType.VirtualWAN)
	if err != nil {
		return VirtualWANResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}