package armdataboxedge

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

type AddonsCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type AddonsDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type BandwidthSchedulesCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type BandwidthSchedulesDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type ContainersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type ContainersDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type ContainersRefreshPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type DevicesCreateOrUpdateSecuritySettingsPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type DevicesDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type DevicesDownloadUpdatesPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type DevicesInstallUpdatesPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type DevicesScanForUpdatesPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type MonitoringConfigCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type MonitoringConfigDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type OrdersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type OrdersDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type RolesCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type RolesDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type SharesCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type SharesDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type SharesRefreshPoller struct {
	pt *azcore.Poller
}

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

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

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

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

type StorageAccountCredentialsCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type StorageAccountCredentialsDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type StorageAccountsCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type StorageAccountsDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type SupportPackagesTriggerSupportPackagePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type TriggersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type TriggersDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type UsersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

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

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

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

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

type UsersDeletePoller struct {
	pt *azcore.Poller
}

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

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

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

func (p *UsersDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}
//go:build go1.16
// +build go1.16

// 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 armdataboxedge

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

// AddonsCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type AddonsCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *AddonsCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *AddonsCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 AddonsCreateOrUpdateResponse will be returned.
func (p *AddonsCreateOrUpdatePoller) FinalResponse(ctx context.Context) (AddonsCreateOrUpdateResponse, error) {
	respType := AddonsCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.AddonClassification)
	if err != nil {
		return AddonsCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *AddonsCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// AddonsDeletePoller provides polling facilities until the operation reaches a terminal state.
type AddonsDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *AddonsDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *AddonsDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 AddonsDeleteResponse will be returned.
func (p *AddonsDeletePoller) FinalResponse(ctx context.Context) (AddonsDeleteResponse, error) {
	respType := AddonsDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return AddonsDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *AddonsDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// BandwidthSchedulesCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type BandwidthSchedulesCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *BandwidthSchedulesCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *BandwidthSchedulesCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 BandwidthSchedulesCreateOrUpdateResponse will be returned.
func (p *BandwidthSchedulesCreateOrUpdatePoller) FinalResponse(ctx context.Context) (BandwidthSchedulesCreateOrUpdateResponse, error) {
	respType := BandwidthSchedulesCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.BandwidthSchedule)
	if err != nil {
		return BandwidthSchedulesCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *BandwidthSchedulesCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// BandwidthSchedulesDeletePoller provides polling facilities until the operation reaches a terminal state.
type BandwidthSchedulesDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *BandwidthSchedulesDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *BandwidthSchedulesDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 BandwidthSchedulesDeleteResponse will be returned.
func (p *BandwidthSchedulesDeletePoller) FinalResponse(ctx context.Context) (BandwidthSchedulesDeleteResponse, error) {
	respType := BandwidthSchedulesDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return BandwidthSchedulesDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *BandwidthSchedulesDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// ContainersCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type ContainersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *ContainersCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *ContainersCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 ContainersCreateOrUpdateResponse will be returned.
func (p *ContainersCreateOrUpdatePoller) FinalResponse(ctx context.Context) (ContainersCreateOrUpdateResponse, error) {
	respType := ContainersCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.Container)
	if err != nil {
		return ContainersCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *ContainersCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// ContainersDeletePoller provides polling facilities until the operation reaches a terminal state.
type ContainersDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *ContainersDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *ContainersDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 ContainersDeleteResponse will be returned.
func (p *ContainersDeletePoller) FinalResponse(ctx context.Context) (ContainersDeleteResponse, error) {
	respType := ContainersDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return ContainersDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *ContainersDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// ContainersRefreshPoller provides polling facilities until the operation reaches a terminal state.
type ContainersRefreshPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *ContainersRefreshPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *ContainersRefreshPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 ContainersRefreshResponse will be returned.
func (p *ContainersRefreshPoller) FinalResponse(ctx context.Context) (ContainersRefreshResponse, error) {
	respType := ContainersRefreshResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return ContainersRefreshResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *ContainersRefreshPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// DevicesCreateOrUpdateSecuritySettingsPoller provides polling facilities until the operation reaches a terminal state.
type DevicesCreateOrUpdateSecuritySettingsPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *DevicesCreateOrUpdateSecuritySettingsPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *DevicesCreateOrUpdateSecuritySettingsPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 DevicesCreateOrUpdateSecuritySettingsResponse will be returned.
func (p *DevicesCreateOrUpdateSecuritySettingsPoller) FinalResponse(ctx context.Context) (DevicesCreateOrUpdateSecuritySettingsResponse, error) {
	respType := DevicesCreateOrUpdateSecuritySettingsResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return DevicesCreateOrUpdateSecuritySettingsResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *DevicesCreateOrUpdateSecuritySettingsPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// DevicesDeletePoller provides polling facilities until the operation reaches a terminal state.
type DevicesDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *DevicesDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *DevicesDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 DevicesDeleteResponse will be returned.
func (p *DevicesDeletePoller) FinalResponse(ctx context.Context) (DevicesDeleteResponse, error) {
	respType := DevicesDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return DevicesDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *DevicesDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// DevicesDownloadUpdatesPoller provides polling facilities until the operation reaches a terminal state.
type DevicesDownloadUpdatesPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *DevicesDownloadUpdatesPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *DevicesDownloadUpdatesPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 DevicesDownloadUpdatesResponse will be returned.
func (p *DevicesDownloadUpdatesPoller) FinalResponse(ctx context.Context) (DevicesDownloadUpdatesResponse, error) {
	respType := DevicesDownloadUpdatesResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return DevicesDownloadUpdatesResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *DevicesDownloadUpdatesPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// DevicesInstallUpdatesPoller provides polling facilities until the operation reaches a terminal state.
type DevicesInstallUpdatesPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *DevicesInstallUpdatesPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *DevicesInstallUpdatesPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 DevicesInstallUpdatesResponse will be returned.
func (p *DevicesInstallUpdatesPoller) FinalResponse(ctx context.Context) (DevicesInstallUpdatesResponse, error) {
	respType := DevicesInstallUpdatesResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return DevicesInstallUpdatesResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *DevicesInstallUpdatesPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// DevicesScanForUpdatesPoller provides polling facilities until the operation reaches a terminal state.
type DevicesScanForUpdatesPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *DevicesScanForUpdatesPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *DevicesScanForUpdatesPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 DevicesScanForUpdatesResponse will be returned.
func (p *DevicesScanForUpdatesPoller) FinalResponse(ctx context.Context) (DevicesScanForUpdatesResponse, error) {
	respType := DevicesScanForUpdatesResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return DevicesScanForUpdatesResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *DevicesScanForUpdatesPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsPoller provides polling facilities until the operation reaches a terminal state.
type DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsResponse will be returned.
func (p *DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsPoller) FinalResponse(ctx context.Context) (DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsResponse, error) {
	respType := DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.DiagnosticProactiveLogCollectionSettings)
	if err != nil {
		return DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *DiagnosticSettingsUpdateDiagnosticProactiveLogCollectionSettingsPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsPoller provides polling facilities until the operation reaches a terminal state.
type DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsResponse will be returned.
func (p *DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsPoller) FinalResponse(ctx context.Context) (DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsResponse, error) {
	respType := DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.DiagnosticRemoteSupportSettings)
	if err != nil {
		return DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *DiagnosticSettingsUpdateDiagnosticRemoteSupportSettingsPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// MonitoringConfigCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type MonitoringConfigCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *MonitoringConfigCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *MonitoringConfigCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 MonitoringConfigCreateOrUpdateResponse will be returned.
func (p *MonitoringConfigCreateOrUpdatePoller) FinalResponse(ctx context.Context) (MonitoringConfigCreateOrUpdateResponse, error) {
	respType := MonitoringConfigCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.MonitoringMetricConfiguration)
	if err != nil {
		return MonitoringConfigCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *MonitoringConfigCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// MonitoringConfigDeletePoller provides polling facilities until the operation reaches a terminal state.
type MonitoringConfigDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *MonitoringConfigDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *MonitoringConfigDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 MonitoringConfigDeleteResponse will be returned.
func (p *MonitoringConfigDeletePoller) FinalResponse(ctx context.Context) (MonitoringConfigDeleteResponse, error) {
	respType := MonitoringConfigDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return MonitoringConfigDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *MonitoringConfigDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// OrdersCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type OrdersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *OrdersCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *OrdersCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 OrdersCreateOrUpdateResponse will be returned.
func (p *OrdersCreateOrUpdatePoller) FinalResponse(ctx context.Context) (OrdersCreateOrUpdateResponse, error) {
	respType := OrdersCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.Order)
	if err != nil {
		return OrdersCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *OrdersCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// OrdersDeletePoller provides polling facilities until the operation reaches a terminal state.
type OrdersDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *OrdersDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *OrdersDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 OrdersDeleteResponse will be returned.
func (p *OrdersDeletePoller) FinalResponse(ctx context.Context) (OrdersDeleteResponse, error) {
	respType := OrdersDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return OrdersDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *OrdersDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// RolesCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type RolesCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *RolesCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *RolesCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 RolesCreateOrUpdateResponse will be returned.
func (p *RolesCreateOrUpdatePoller) FinalResponse(ctx context.Context) (RolesCreateOrUpdateResponse, error) {
	respType := RolesCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.RoleClassification)
	if err != nil {
		return RolesCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *RolesCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// RolesDeletePoller provides polling facilities until the operation reaches a terminal state.
type RolesDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *RolesDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *RolesDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 RolesDeleteResponse will be returned.
func (p *RolesDeletePoller) FinalResponse(ctx context.Context) (RolesDeleteResponse, error) {
	respType := RolesDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return RolesDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *RolesDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// SharesCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type SharesCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *SharesCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *SharesCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 SharesCreateOrUpdateResponse will be returned.
func (p *SharesCreateOrUpdatePoller) FinalResponse(ctx context.Context) (SharesCreateOrUpdateResponse, error) {
	respType := SharesCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.Share)
	if err != nil {
		return SharesCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *SharesCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// SharesDeletePoller provides polling facilities until the operation reaches a terminal state.
type SharesDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *SharesDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *SharesDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 SharesDeleteResponse will be returned.
func (p *SharesDeletePoller) FinalResponse(ctx context.Context) (SharesDeleteResponse, error) {
	respType := SharesDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return SharesDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *SharesDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// SharesRefreshPoller provides polling facilities until the operation reaches a terminal state.
type SharesRefreshPoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *SharesRefreshPoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *SharesRefreshPoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 SharesRefreshResponse will be returned.
func (p *SharesRefreshPoller) FinalResponse(ctx context.Context) (SharesRefreshResponse, error) {
	respType := SharesRefreshResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return SharesRefreshResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *SharesRefreshPoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// StorageAccountCredentialsCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type StorageAccountCredentialsCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *StorageAccountCredentialsCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *StorageAccountCredentialsCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 StorageAccountCredentialsCreateOrUpdateResponse will be returned.
func (p *StorageAccountCredentialsCreateOrUpdatePoller) FinalResponse(ctx context.Context) (StorageAccountCredentialsCreateOrUpdateResponse, error) {
	respType := StorageAccountCredentialsCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.StorageAccountCredential)
	if err != nil {
		return StorageAccountCredentialsCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *StorageAccountCredentialsCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// StorageAccountCredentialsDeletePoller provides polling facilities until the operation reaches a terminal state.
type StorageAccountCredentialsDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *StorageAccountCredentialsDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *StorageAccountCredentialsDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 StorageAccountCredentialsDeleteResponse will be returned.
func (p *StorageAccountCredentialsDeletePoller) FinalResponse(ctx context.Context) (StorageAccountCredentialsDeleteResponse, error) {
	respType := StorageAccountCredentialsDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return StorageAccountCredentialsDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *StorageAccountCredentialsDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// StorageAccountsCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type StorageAccountsCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *StorageAccountsCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *StorageAccountsCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 StorageAccountsCreateOrUpdateResponse will be returned.
func (p *StorageAccountsCreateOrUpdatePoller) FinalResponse(ctx context.Context) (StorageAccountsCreateOrUpdateResponse, error) {
	respType := StorageAccountsCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.StorageAccount)
	if err != nil {
		return StorageAccountsCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *StorageAccountsCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// StorageAccountsDeletePoller provides polling facilities until the operation reaches a terminal state.
type StorageAccountsDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *StorageAccountsDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *StorageAccountsDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 StorageAccountsDeleteResponse will be returned.
func (p *StorageAccountsDeletePoller) FinalResponse(ctx context.Context) (StorageAccountsDeleteResponse, error) {
	respType := StorageAccountsDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return StorageAccountsDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *StorageAccountsDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// SupportPackagesTriggerSupportPackagePoller provides polling facilities until the operation reaches a terminal state.
type SupportPackagesTriggerSupportPackagePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *SupportPackagesTriggerSupportPackagePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *SupportPackagesTriggerSupportPackagePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 SupportPackagesTriggerSupportPackageResponse will be returned.
func (p *SupportPackagesTriggerSupportPackagePoller) FinalResponse(ctx context.Context) (SupportPackagesTriggerSupportPackageResponse, error) {
	respType := SupportPackagesTriggerSupportPackageResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return SupportPackagesTriggerSupportPackageResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *SupportPackagesTriggerSupportPackagePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// TriggersCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type TriggersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *TriggersCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *TriggersCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 TriggersCreateOrUpdateResponse will be returned.
func (p *TriggersCreateOrUpdatePoller) FinalResponse(ctx context.Context) (TriggersCreateOrUpdateResponse, error) {
	respType := TriggersCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.TriggerClassification)
	if err != nil {
		return TriggersCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *TriggersCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// TriggersDeletePoller provides polling facilities until the operation reaches a terminal state.
type TriggersDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *TriggersDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *TriggersDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 TriggersDeleteResponse will be returned.
func (p *TriggersDeletePoller) FinalResponse(ctx context.Context) (TriggersDeleteResponse, error) {
	respType := TriggersDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return TriggersDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *TriggersDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// UsersCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.
type UsersCreateOrUpdatePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *UsersCreateOrUpdatePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *UsersCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 UsersCreateOrUpdateResponse will be returned.
func (p *UsersCreateOrUpdatePoller) FinalResponse(ctx context.Context) (UsersCreateOrUpdateResponse, error) {
	respType := UsersCreateOrUpdateResponse{}
	resp, err := p.pt.FinalResponse(ctx, &respType.User)
	if err != nil {
		return UsersCreateOrUpdateResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *UsersCreateOrUpdatePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}

// UsersDeletePoller provides polling facilities until the operation reaches a terminal state.
type UsersDeletePoller struct {
	pt *azcore.Poller
}

// Done returns true if the LRO has reached a terminal state.
func (p *UsersDeletePoller) Done() bool {
	return p.pt.Done()
}

// Poll fetches the latest state of the LRO.  It returns an HTTP response or error.
// If the LRO has completed successfully, the poller's state is updated and the HTTP
// response is returned.
// If the LRO has completed with failure or was cancelled, the poller's state is
// updated and the error is returned.
// If the LRO has not reached a terminal state, the poller's state is updated and
// the latest HTTP response is returned.
// If Poll fails, the poller's state is unmodified and the error is returned.
// Calling Poll on an LRO that has reached a terminal state will return the final
// HTTP response or error.
func (p *UsersDeletePoller) Poll(ctx context.Context) (*http.Response, error) {
	return p.pt.Poll(ctx)
}

// 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 UsersDeleteResponse will be returned.
func (p *UsersDeletePoller) FinalResponse(ctx context.Context) (UsersDeleteResponse, error) {
	respType := UsersDeleteResponse{}
	resp, err := p.pt.FinalResponse(ctx, nil)
	if err != nil {
		return UsersDeleteResponse{}, err
	}
	respType.RawResponse = resp
	return respType, nil
}

// ResumeToken returns a value representing the poller that can be used to resume
// the LRO at a later time. ResumeTokens are unique per service operation.
func (p *UsersDeletePoller) ResumeToken() (string, error) {
	return p.pt.ResumeToken()
}
