2020-09-30/armcompute/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 armcompute

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

// AccessURIPoller provides polling facilities until the operation completes
type AccessURIPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (AccessURIResponse, error)
	ResumeToken() (string, error)
}

type accessUriPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *accessUriPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *accessUriPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *accessUriPoller) FinalResponse(ctx context.Context) (AccessURIResponse, error) {
	respType := AccessURIResponse{AccessURI: &AccessURI{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.AccessURI)
	if err != nil {
		return AccessURIResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeAccessURIPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *accessUriPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *accessUriPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (AccessURIResponse, error) {
	respType := AccessURIResponse{AccessURI: &AccessURI{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.AccessURI)
	if err != nil {
		return AccessURIResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ContainerServicePoller provides polling facilities until the operation completes
type ContainerServicePoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (ContainerServiceResponse, error)
	ResumeToken() (string, error)
}

type containerServicePoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *containerServicePoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *containerServicePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *containerServicePoller) FinalResponse(ctx context.Context) (ContainerServiceResponse, error) {
	respType := ContainerServiceResponse{ContainerService: &ContainerService{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.ContainerService)
	if err != nil {
		return ContainerServiceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeContainerServicePoller method
// on the client to create a new poller from the data held in the current poller type
func (p *containerServicePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *containerServicePoller) pollUntilDone(ctx context.Context, frequency time.Duration) (ContainerServiceResponse, error) {
	respType := ContainerServiceResponse{ContainerService: &ContainerService{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.ContainerService)
	if err != nil {
		return ContainerServiceResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// DedicatedHostPoller provides polling facilities until the operation completes
type DedicatedHostPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (DedicatedHostResponse, error)
	ResumeToken() (string, error)
}

type dedicatedHostPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *dedicatedHostPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *dedicatedHostPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *dedicatedHostPoller) FinalResponse(ctx context.Context) (DedicatedHostResponse, error) {
	respType := DedicatedHostResponse{DedicatedHost: &DedicatedHost{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.DedicatedHost)
	if err != nil {
		return DedicatedHostResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeDedicatedHostPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *dedicatedHostPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *dedicatedHostPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (DedicatedHostResponse, error) {
	respType := DedicatedHostResponse{DedicatedHost: &DedicatedHost{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.DedicatedHost)
	if err != nil {
		return DedicatedHostResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// DiskAccessPoller provides polling facilities until the operation completes
type DiskAccessPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (DiskAccessResponse, error)
	ResumeToken() (string, error)
}

type diskAccessPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *diskAccessPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *diskAccessPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *diskAccessPoller) FinalResponse(ctx context.Context) (DiskAccessResponse, error) {
	respType := DiskAccessResponse{DiskAccess: &DiskAccess{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.DiskAccess)
	if err != nil {
		return DiskAccessResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeDiskAccessPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *diskAccessPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *diskAccessPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (DiskAccessResponse, error) {
	respType := DiskAccessResponse{DiskAccess: &DiskAccess{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.DiskAccess)
	if err != nil {
		return DiskAccessResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// DiskEncryptionSetPoller provides polling facilities until the operation completes
type DiskEncryptionSetPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (DiskEncryptionSetResponse, error)
	ResumeToken() (string, error)
}

type diskEncryptionSetPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *diskEncryptionSetPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *diskEncryptionSetPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *diskEncryptionSetPoller) FinalResponse(ctx context.Context) (DiskEncryptionSetResponse, error) {
	respType := DiskEncryptionSetResponse{DiskEncryptionSet: &DiskEncryptionSet{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.DiskEncryptionSet)
	if err != nil {
		return DiskEncryptionSetResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeDiskEncryptionSetPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *diskEncryptionSetPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *diskEncryptionSetPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (DiskEncryptionSetResponse, error) {
	respType := DiskEncryptionSetResponse{DiskEncryptionSet: &DiskEncryptionSet{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.DiskEncryptionSet)
	if err != nil {
		return DiskEncryptionSetResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// DiskPoller provides polling facilities until the operation completes
type DiskPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (DiskResponse, error)
	ResumeToken() (string, error)
}

type diskPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *diskPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *diskPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *diskPoller) FinalResponse(ctx context.Context) (DiskResponse, error) {
	respType := DiskResponse{Disk: &Disk{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.Disk)
	if err != nil {
		return DiskResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeDiskPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *diskPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *diskPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (DiskResponse, error) {
	respType := DiskResponse{Disk: &Disk{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.Disk)
	if err != nil {
		return DiskResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// GalleryApplicationPoller provides polling facilities until the operation completes
type GalleryApplicationPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (GalleryApplicationResponse, error)
	ResumeToken() (string, error)
}

type galleryApplicationPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *galleryApplicationPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *galleryApplicationPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *galleryApplicationPoller) FinalResponse(ctx context.Context) (GalleryApplicationResponse, error) {
	respType := GalleryApplicationResponse{GalleryApplication: &GalleryApplication{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.GalleryApplication)
	if err != nil {
		return GalleryApplicationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeGalleryApplicationPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *galleryApplicationPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *galleryApplicationPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (GalleryApplicationResponse, error) {
	respType := GalleryApplicationResponse{GalleryApplication: &GalleryApplication{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.GalleryApplication)
	if err != nil {
		return GalleryApplicationResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// GalleryApplicationVersionPoller provides polling facilities until the operation completes
type GalleryApplicationVersionPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (GalleryApplicationVersionResponse, error)
	ResumeToken() (string, error)
}

type galleryApplicationVersionPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *galleryApplicationVersionPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *galleryApplicationVersionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *galleryApplicationVersionPoller) FinalResponse(ctx context.Context) (GalleryApplicationVersionResponse, error) {
	respType := GalleryApplicationVersionResponse{GalleryApplicationVersion: &GalleryApplicationVersion{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.GalleryApplicationVersion)
	if err != nil {
		return GalleryApplicationVersionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeGalleryApplicationVersionPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *galleryApplicationVersionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *galleryApplicationVersionPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (GalleryApplicationVersionResponse, error) {
	respType := GalleryApplicationVersionResponse{GalleryApplicationVersion: &GalleryApplicationVersion{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.GalleryApplicationVersion)
	if err != nil {
		return GalleryApplicationVersionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// GalleryImagePoller provides polling facilities until the operation completes
type GalleryImagePoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (GalleryImageResponse, error)
	ResumeToken() (string, error)
}

type galleryImagePoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *galleryImagePoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *galleryImagePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *galleryImagePoller) FinalResponse(ctx context.Context) (GalleryImageResponse, error) {
	respType := GalleryImageResponse{GalleryImage: &GalleryImage{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.GalleryImage)
	if err != nil {
		return GalleryImageResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeGalleryImagePoller method
// on the client to create a new poller from the data held in the current poller type
func (p *galleryImagePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *galleryImagePoller) pollUntilDone(ctx context.Context, frequency time.Duration) (GalleryImageResponse, error) {
	respType := GalleryImageResponse{GalleryImage: &GalleryImage{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.GalleryImage)
	if err != nil {
		return GalleryImageResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// GalleryImageVersionPoller provides polling facilities until the operation completes
type GalleryImageVersionPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (GalleryImageVersionResponse, error)
	ResumeToken() (string, error)
}

type galleryImageVersionPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *galleryImageVersionPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *galleryImageVersionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *galleryImageVersionPoller) FinalResponse(ctx context.Context) (GalleryImageVersionResponse, error) {
	respType := GalleryImageVersionResponse{GalleryImageVersion: &GalleryImageVersion{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.GalleryImageVersion)
	if err != nil {
		return GalleryImageVersionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeGalleryImageVersionPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *galleryImageVersionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *galleryImageVersionPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (GalleryImageVersionResponse, error) {
	respType := GalleryImageVersionResponse{GalleryImageVersion: &GalleryImageVersion{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.GalleryImageVersion)
	if err != nil {
		return GalleryImageVersionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// GalleryPoller provides polling facilities until the operation completes
type GalleryPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (GalleryResponse, error)
	ResumeToken() (string, error)
}

type galleryPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *galleryPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *galleryPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *galleryPoller) FinalResponse(ctx context.Context) (GalleryResponse, error) {
	respType := GalleryResponse{Gallery: &Gallery{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.Gallery)
	if err != nil {
		return GalleryResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeGalleryPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *galleryPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *galleryPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (GalleryResponse, error) {
	respType := GalleryResponse{Gallery: &Gallery{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.Gallery)
	if err != nil {
		return GalleryResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// HTTPPoller provides polling facilities until the operation completes
type HTTPPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (*http.Response, error)
	ResumeToken() (string, error)
}

type httpPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *httpPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *httpPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

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

// ResumeToken generates the string token that can be used with the ResumeHTTPPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *httpPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

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

// ImagePoller provides polling facilities until the operation completes
type ImagePoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (ImageResponse, error)
	ResumeToken() (string, error)
}

type imagePoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *imagePoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *imagePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *imagePoller) FinalResponse(ctx context.Context) (ImageResponse, error) {
	respType := ImageResponse{Image: &Image{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.Image)
	if err != nil {
		return ImageResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeImagePoller method
// on the client to create a new poller from the data held in the current poller type
func (p *imagePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *imagePoller) pollUntilDone(ctx context.Context, frequency time.Duration) (ImageResponse, error) {
	respType := ImageResponse{Image: &Image{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.Image)
	if err != nil {
		return ImageResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// LogAnalyticsOperationResultPoller provides polling facilities until the operation completes
type LogAnalyticsOperationResultPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (LogAnalyticsOperationResultResponse, error)
	ResumeToken() (string, error)
}

type logAnalyticsOperationResultPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *logAnalyticsOperationResultPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *logAnalyticsOperationResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *logAnalyticsOperationResultPoller) FinalResponse(ctx context.Context) (LogAnalyticsOperationResultResponse, error) {
	respType := LogAnalyticsOperationResultResponse{LogAnalyticsOperationResult: &LogAnalyticsOperationResult{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.LogAnalyticsOperationResult)
	if err != nil {
		return LogAnalyticsOperationResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeLogAnalyticsOperationResultPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *logAnalyticsOperationResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *logAnalyticsOperationResultPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (LogAnalyticsOperationResultResponse, error) {
	respType := LogAnalyticsOperationResultResponse{LogAnalyticsOperationResult: &LogAnalyticsOperationResult{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.LogAnalyticsOperationResult)
	if err != nil {
		return LogAnalyticsOperationResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// PrivateEndpointConnectionPoller provides polling facilities until the operation completes
type PrivateEndpointConnectionPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (PrivateEndpointConnectionResponse, error)
	ResumeToken() (string, error)
}

type privateEndpointConnectionPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *privateEndpointConnectionPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *privateEndpointConnectionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *privateEndpointConnectionPoller) FinalResponse(ctx context.Context) (PrivateEndpointConnectionResponse, error) {
	respType := PrivateEndpointConnectionResponse{PrivateEndpointConnection: &PrivateEndpointConnection{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.PrivateEndpointConnection)
	if err != nil {
		return PrivateEndpointConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumePrivateEndpointConnectionPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *privateEndpointConnectionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *privateEndpointConnectionPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (PrivateEndpointConnectionResponse, error) {
	respType := PrivateEndpointConnectionResponse{PrivateEndpointConnection: &PrivateEndpointConnection{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.PrivateEndpointConnection)
	if err != nil {
		return PrivateEndpointConnectionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// RunCommandResultPoller provides polling facilities until the operation completes
type RunCommandResultPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (RunCommandResultResponse, error)
	ResumeToken() (string, error)
}

type runCommandResultPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *runCommandResultPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *runCommandResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *runCommandResultPoller) FinalResponse(ctx context.Context) (RunCommandResultResponse, error) {
	respType := RunCommandResultResponse{RunCommandResult: &RunCommandResult{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.RunCommandResult)
	if err != nil {
		return RunCommandResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeRunCommandResultPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *runCommandResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *runCommandResultPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (RunCommandResultResponse, error) {
	respType := RunCommandResultResponse{RunCommandResult: &RunCommandResult{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.RunCommandResult)
	if err != nil {
		return RunCommandResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// SharingUpdatePoller provides polling facilities until the operation completes
type SharingUpdatePoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (SharingUpdateResponse, error)
	ResumeToken() (string, error)
}

type sharingUpdatePoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *sharingUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *sharingUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *sharingUpdatePoller) FinalResponse(ctx context.Context) (SharingUpdateResponse, error) {
	respType := SharingUpdateResponse{SharingUpdate: &SharingUpdate{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.SharingUpdate)
	if err != nil {
		return SharingUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeSharingUpdatePoller method
// on the client to create a new poller from the data held in the current poller type
func (p *sharingUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *sharingUpdatePoller) pollUntilDone(ctx context.Context, frequency time.Duration) (SharingUpdateResponse, error) {
	respType := SharingUpdateResponse{SharingUpdate: &SharingUpdate{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.SharingUpdate)
	if err != nil {
		return SharingUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// SnapshotPoller provides polling facilities until the operation completes
type SnapshotPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (SnapshotResponse, error)
	ResumeToken() (string, error)
}

type snapshotPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *snapshotPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *snapshotPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *snapshotPoller) FinalResponse(ctx context.Context) (SnapshotResponse, error) {
	respType := SnapshotResponse{Snapshot: &Snapshot{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.Snapshot)
	if err != nil {
		return SnapshotResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeSnapshotPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *snapshotPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *snapshotPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (SnapshotResponse, error) {
	respType := SnapshotResponse{Snapshot: &Snapshot{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.Snapshot)
	if err != nil {
		return SnapshotResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineAssessPatchesResultPoller provides polling facilities until the operation completes
type VirtualMachineAssessPatchesResultPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineAssessPatchesResultResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineAssessPatchesResultPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineAssessPatchesResultPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineAssessPatchesResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineAssessPatchesResultPoller) FinalResponse(ctx context.Context) (VirtualMachineAssessPatchesResultResponse, error) {
	respType := VirtualMachineAssessPatchesResultResponse{VirtualMachineAssessPatchesResult: &VirtualMachineAssessPatchesResult{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineAssessPatchesResult)
	if err != nil {
		return VirtualMachineAssessPatchesResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineAssessPatchesResultPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineAssessPatchesResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineAssessPatchesResultPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineAssessPatchesResultResponse, error) {
	respType := VirtualMachineAssessPatchesResultResponse{VirtualMachineAssessPatchesResult: &VirtualMachineAssessPatchesResult{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineAssessPatchesResult)
	if err != nil {
		return VirtualMachineAssessPatchesResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineCaptureResultPoller provides polling facilities until the operation completes
type VirtualMachineCaptureResultPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineCaptureResultResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineCaptureResultPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineCaptureResultPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineCaptureResultPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineCaptureResultPoller) FinalResponse(ctx context.Context) (VirtualMachineCaptureResultResponse, error) {
	respType := VirtualMachineCaptureResultResponse{VirtualMachineCaptureResult: &VirtualMachineCaptureResult{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineCaptureResult)
	if err != nil {
		return VirtualMachineCaptureResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineCaptureResultPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineCaptureResultPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineCaptureResultPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineCaptureResultResponse, error) {
	respType := VirtualMachineCaptureResultResponse{VirtualMachineCaptureResult: &VirtualMachineCaptureResult{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineCaptureResult)
	if err != nil {
		return VirtualMachineCaptureResultResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineExtensionPoller provides polling facilities until the operation completes
type VirtualMachineExtensionPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineExtensionResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineExtensionPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineExtensionPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineExtensionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineExtensionPoller) FinalResponse(ctx context.Context) (VirtualMachineExtensionResponse, error) {
	respType := VirtualMachineExtensionResponse{VirtualMachineExtension: &VirtualMachineExtension{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineExtension)
	if err != nil {
		return VirtualMachineExtensionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineExtensionPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineExtensionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineExtensionPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineExtensionResponse, error) {
	respType := VirtualMachineExtensionResponse{VirtualMachineExtension: &VirtualMachineExtension{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineExtension)
	if err != nil {
		return VirtualMachineExtensionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachinePoller provides polling facilities until the operation completes
type VirtualMachinePoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineResponse, error)
	ResumeToken() (string, error)
}

type virtualMachinePoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachinePoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachinePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachinePoller) FinalResponse(ctx context.Context) (VirtualMachineResponse, error) {
	respType := VirtualMachineResponse{VirtualMachine: &VirtualMachine{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachine)
	if err != nil {
		return VirtualMachineResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachinePoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachinePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachinePoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineResponse, error) {
	respType := VirtualMachineResponse{VirtualMachine: &VirtualMachine{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachine)
	if err != nil {
		return VirtualMachineResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineRunCommandPoller provides polling facilities until the operation completes
type VirtualMachineRunCommandPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineRunCommandResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineRunCommandPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineRunCommandPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineRunCommandPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineRunCommandPoller) FinalResponse(ctx context.Context) (VirtualMachineRunCommandResponse, error) {
	respType := VirtualMachineRunCommandResponse{VirtualMachineRunCommand: &VirtualMachineRunCommand{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineRunCommand)
	if err != nil {
		return VirtualMachineRunCommandResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineRunCommandPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineRunCommandPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineRunCommandPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineRunCommandResponse, error) {
	respType := VirtualMachineRunCommandResponse{VirtualMachineRunCommand: &VirtualMachineRunCommand{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineRunCommand)
	if err != nil {
		return VirtualMachineRunCommandResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineScaleSetExtensionPoller provides polling facilities until the operation completes
type VirtualMachineScaleSetExtensionPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineScaleSetExtensionResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineScaleSetExtensionPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineScaleSetExtensionPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineScaleSetExtensionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineScaleSetExtensionPoller) FinalResponse(ctx context.Context) (VirtualMachineScaleSetExtensionResponse, error) {
	respType := VirtualMachineScaleSetExtensionResponse{VirtualMachineScaleSetExtension: &VirtualMachineScaleSetExtension{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineScaleSetExtension)
	if err != nil {
		return VirtualMachineScaleSetExtensionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineScaleSetExtensionPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineScaleSetExtensionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineScaleSetExtensionPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineScaleSetExtensionResponse, error) {
	respType := VirtualMachineScaleSetExtensionResponse{VirtualMachineScaleSetExtension: &VirtualMachineScaleSetExtension{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineScaleSetExtension)
	if err != nil {
		return VirtualMachineScaleSetExtensionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineScaleSetPoller provides polling facilities until the operation completes
type VirtualMachineScaleSetPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineScaleSetResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineScaleSetPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineScaleSetPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineScaleSetPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineScaleSetPoller) FinalResponse(ctx context.Context) (VirtualMachineScaleSetResponse, error) {
	respType := VirtualMachineScaleSetResponse{VirtualMachineScaleSet: &VirtualMachineScaleSet{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineScaleSet)
	if err != nil {
		return VirtualMachineScaleSetResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineScaleSetPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineScaleSetPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineScaleSetPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineScaleSetResponse, error) {
	respType := VirtualMachineScaleSetResponse{VirtualMachineScaleSet: &VirtualMachineScaleSet{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineScaleSet)
	if err != nil {
		return VirtualMachineScaleSetResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineScaleSetVMExtensionPoller provides polling facilities until the operation completes
type VirtualMachineScaleSetVMExtensionPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineScaleSetVMExtensionResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineScaleSetVMExtensionPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineScaleSetVMExtensionPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineScaleSetVMExtensionPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineScaleSetVMExtensionPoller) FinalResponse(ctx context.Context) (VirtualMachineScaleSetVMExtensionResponse, error) {
	respType := VirtualMachineScaleSetVMExtensionResponse{VirtualMachineScaleSetVMExtension: &VirtualMachineScaleSetVMExtension{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineScaleSetVMExtension)
	if err != nil {
		return VirtualMachineScaleSetVMExtensionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineScaleSetVMExtensionPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineScaleSetVMExtensionPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineScaleSetVMExtensionPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineScaleSetVMExtensionResponse, error) {
	respType := VirtualMachineScaleSetVMExtensionResponse{VirtualMachineScaleSetVMExtension: &VirtualMachineScaleSetVMExtension{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineScaleSetVMExtension)
	if err != nil {
		return VirtualMachineScaleSetVMExtensionResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// VirtualMachineScaleSetVMPoller provides polling facilities until the operation completes
type VirtualMachineScaleSetVMPoller interface {
	Done() bool
	Poll(ctx context.Context) (*http.Response, error)
	FinalResponse(ctx context.Context) (VirtualMachineScaleSetVMResponse, error)
	ResumeToken() (string, error)
}

type virtualMachineScaleSetVMPoller struct {
	// the client for making the request
	pipeline azcore.Pipeline
	pt       armcore.Poller
}

// Done returns true if there was an error or polling has reached a terminal state
func (p *virtualMachineScaleSetVMPoller) Done() bool {
	return p.pt.Done()
}

// Poll will send poll the service endpoint and return an http.Response or error received from the service
func (p *virtualMachineScaleSetVMPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx, p.pipeline)
}

func (p *virtualMachineScaleSetVMPoller) FinalResponse(ctx context.Context) (VirtualMachineScaleSetVMResponse, error) {
	respType := VirtualMachineScaleSetVMResponse{VirtualMachineScaleSetVM: &VirtualMachineScaleSetVM{}}
	resp, err := p.pt.FinalResponse(ctx, p.pipeline, respType.VirtualMachineScaleSetVM)
	if err != nil {
		return VirtualMachineScaleSetVMResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken generates the string token that can be used with the ResumeVirtualMachineScaleSetVMPoller method
// on the client to create a new poller from the data held in the current poller type
func (p *virtualMachineScaleSetVMPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

func (p *virtualMachineScaleSetVMPoller) pollUntilDone(ctx context.Context, frequency time.Duration) (VirtualMachineScaleSetVMResponse, error) {
	respType := VirtualMachineScaleSetVMResponse{VirtualMachineScaleSetVM: &VirtualMachineScaleSetVM{}}
	resp, err := p.pt.PollUntilDone(ctx, frequency, p.pipeline, respType.VirtualMachineScaleSetVM)
	if err != nil {
		return VirtualMachineScaleSetVMResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}