func (l LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingResponse, error) {
	respType := LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received.
freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second.
package lrogroup
import (
	"context"
	armruntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm/runtime"
	"net/http"
	"time"
)
type LRORetrysDelete202Retry200PollerResponse struct {
	Poller *LRORetrysDelete202Retry200Poller
	RawResponse *http.Response
}
func (l LRORetrysDelete202Retry200PollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LRORetrysDelete202Retry200Response, error) {
	respType := LRORetrysDelete202Retry200Response{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LRORetrysDelete202Retry200PollerResponse) Resume(ctx context.Context, client *LRORetrysClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LRORetrysClient.Delete202Retry200", token, client.con.Pipeline(), client.delete202Retry200HandleError)
	if err != nil {
		return err
	}
	poller := &LRORetrysDelete202Retry200Poller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LRORetrysDelete202Retry200Response struct {
	RawResponse *http.Response
}
type LRORetrysDeleteAsyncRelativeRetrySucceededPollerResponse struct {
	Poller *LRORetrysDeleteAsyncRelativeRetrySucceededPoller
	RawResponse *http.Response
}
func (l LRORetrysDeleteAsyncRelativeRetrySucceededPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LRORetrysDeleteAsyncRelativeRetrySucceededResponse, error) {
	respType := LRORetrysDeleteAsyncRelativeRetrySucceededResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LRORetrysDeleteAsyncRelativeRetrySucceededPollerResponse) Resume(ctx context.Context, client *LRORetrysClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LRORetrysClient.DeleteAsyncRelativeRetrySucceeded", token, client.con.Pipeline(), client.deleteAsyncRelativeRetrySucceededHandleError)
	if err != nil {
		return err
	}
	poller := &LRORetrysDeleteAsyncRelativeRetrySucceededPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LRORetrysDeleteAsyncRelativeRetrySucceededResponse struct {
	RawResponse *http.Response
}
type LRORetrysDeleteProvisioning202Accepted200SucceededPollerResponse struct {
	Poller *LRORetrysDeleteProvisioning202Accepted200SucceededPoller
	RawResponse *http.Response
}
func (l LRORetrysDeleteProvisioning202Accepted200SucceededPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LRORetrysDeleteProvisioning202Accepted200SucceededResponse, error) {
	respType := LRORetrysDeleteProvisioning202Accepted200SucceededResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, &respType.Product)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LRORetrysDeleteProvisioning202Accepted200SucceededPollerResponse) Resume(ctx context.Context, client *LRORetrysClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LRORetrysClient.DeleteProvisioning202Accepted200Succeeded", token, client.con.Pipeline(), client.deleteProvisioning202Accepted200SucceededHandleError)
	if err != nil {
		return err
	}
	poller := &LRORetrysDeleteProvisioning202Accepted200SucceededPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LRORetrysDeleteProvisioning202Accepted200SucceededResponse struct {
	LRORetrysDeleteProvisioning202Accepted200SucceededResult
	RawResponse *http.Response
}
type LRORetrysDeleteProvisioning202Accepted200SucceededResult struct {
	Product
}
type LRORetrysPost202Retry200PollerResponse struct {
	Poller *LRORetrysPost202Retry200Poller
	RawResponse *http.Response
}
func (l LRORetrysPost202Retry200PollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LRORetrysPost202Retry200Response, error) {
	respType := LRORetrysPost202Retry200Response{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LRORetrysPost202Retry200PollerResponse) Resume(ctx context.Context, client *LRORetrysClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LRORetrysClient.Post202Retry200", token, client.con.Pipeline(), client.post202Retry200HandleError)
	if err != nil {
		return err
	}
	poller := &LRORetrysPost202Retry200Poller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LRORetrysPost202Retry200Response struct {
	RawResponse *http.Response
}
type LRORetrysPostAsyncRelativeRetrySucceededPollerResponse struct {
	Poller *LRORetrysPostAsyncRelativeRetrySucceededPoller
	RawResponse *http.Response
}
func (l LRORetrysPostAsyncRelativeRetrySucceededPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LRORetrysPostAsyncRelativeRetrySucceededResponse, error) {
	respType := LRORetrysPostAsyncRelativeRetrySucceededResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LRORetrysPostAsyncRelativeRetrySucceededPollerResponse) Resume(ctx context.Context, client *LRORetrysClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LRORetrysClient.PostAsyncRelativeRetrySucceeded", token, client.con.Pipeline(), client.postAsyncRelativeRetrySucceededHandleError)
	if err != nil {
		return err
	}
	poller := &LRORetrysPostAsyncRelativeRetrySucceededPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LRORetrysPostAsyncRelativeRetrySucceededResponse struct {
	RawResponse *http.Response
}
type LRORetrysPut201CreatingSucceeded200PollerResponse struct {
	Poller *LRORetrysPut201CreatingSucceeded200Poller
	RawResponse *http.Response
}
func (l LRORetrysPut201CreatingSucceeded200PollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LRORetrysPut201CreatingSucceeded200Response, error) {
	respType := LRORetrysPut201CreatingSucceeded200Response{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, &respType.Product)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LRORetrysPut201CreatingSucceeded200PollerResponse) Resume(ctx context.Context, client *LRORetrysClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LRORetrysClient.Put201CreatingSucceeded200", token, client.con.Pipeline(), client.put201CreatingSucceeded200HandleError)
	if err != nil {
		return err
	}
	poller := &LRORetrysPut201CreatingSucceeded200Poller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LRORetrysPut201CreatingSucceeded200Response struct {
	LRORetrysPut201CreatingSucceeded200Result
	RawResponse *http.Response
}
type LRORetrysPut201CreatingSucceeded200Result struct {
	Product
}
type LRORetrysPutAsyncRelativeRetrySucceededPollerResponse struct {
	Poller *LRORetrysPutAsyncRelativeRetrySucceededPoller
	RawResponse *http.Response
}
func (l LRORetrysPutAsyncRelativeRetrySucceededPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LRORetrysPutAsyncRelativeRetrySucceededResponse, error) {
	respType := LRORetrysPutAsyncRelativeRetrySucceededResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, &respType.Product)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LRORetrysPutAsyncRelativeRetrySucceededPollerResponse) Resume(ctx context.Context, client *LRORetrysClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LRORetrysClient.PutAsyncRelativeRetrySucceeded", token, client.con.Pipeline(), client.putAsyncRelativeRetrySucceededHandleError)
	if err != nil {
		return err
	}
	poller := &LRORetrysPutAsyncRelativeRetrySucceededPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LRORetrysPutAsyncRelativeRetrySucceededResponse struct {
	LRORetrysPutAsyncRelativeRetrySucceededResult
	RawResponse *http.Response
}
type LRORetrysPutAsyncRelativeRetrySucceededResult struct {
	Product
}
type LROSADsDelete202NonRetry400PollerResponse struct {
	Poller *LROSADsDelete202NonRetry400Poller
	RawResponse *http.Response
}
func (l LROSADsDelete202NonRetry400PollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LROSADsDelete202NonRetry400Response, error) {
	respType := LROSADsDelete202NonRetry400Response{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LROSADsDelete202NonRetry400PollerResponse) Resume(ctx context.Context, client *LROSADsClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LROSADsClient.Delete202NonRetry400", token, client.con.Pipeline(), client.delete202NonRetry400HandleError)
	if err != nil {
		return err
	}
	poller := &LROSADsDelete202NonRetry400Poller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LROSADsDelete202NonRetry400Response struct {
	RawResponse *http.Response
}
type LROSADsDelete202RetryInvalidHeaderPollerResponse struct {
	Poller *LROSADsDelete202RetryInvalidHeaderPoller
	RawResponse *http.Response
}
func (l LROSADsDelete202RetryInvalidHeaderPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LROSADsDelete202RetryInvalidHeaderResponse, error) {
	respType := LROSADsDelete202RetryInvalidHeaderResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LROSADsDelete202RetryInvalidHeaderPollerResponse) Resume(ctx context.Context, client *LROSADsClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LROSADsClient.Delete202RetryInvalidHeader", token, client.con.Pipeline(), client.delete202RetryInvalidHeaderHandleError)
	if err != nil {
		return err
	}
	poller := &LROSADsDelete202RetryInvalidHeaderPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LROSADsDelete202RetryInvalidHeaderResponse struct {
	RawResponse *http.Response
}
type LROSADsDelete204SucceededPollerResponse struct {
	Poller *LROSADsDelete204SucceededPoller
	RawResponse *http.Response
}
func (l LROSADsDelete204SucceededPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LROSADsDelete204SucceededResponse, error) {
	respType := LROSADsDelete204SucceededResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LROSADsDelete204SucceededPollerResponse) Resume(ctx context.Context, client *LROSADsClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LROSADsClient.Delete204Succeeded", token, client.con.Pipeline(), client.delete204SucceededHandleError)
	if err != nil {
		return err
	}
	poller := &LROSADsDelete204SucceededPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LROSADsDelete204SucceededResponse struct {
	RawResponse *http.Response
}
type LROSADsDeleteAsyncRelativeRetry400PollerResponse struct {
	Poller *LROSADsDeleteAsyncRelativeRetry400Poller
	RawResponse *http.Response
}
func (l LROSADsDeleteAsyncRelativeRetry400PollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LROSADsDeleteAsyncRelativeRetry400Response, error) {
	respType := LROSADsDeleteAsyncRelativeRetry400Response{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LROSADsDeleteAsyncRelativeRetry400PollerResponse) Resume(ctx context.Context, client *LROSADsClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LROSADsClient.DeleteAsyncRelativeRetry400", token, client.con.Pipeline(), client.deleteAsyncRelativeRetry400HandleError)
	if err != nil {
		return err
	}
	poller := &LROSADsDeleteAsyncRelativeRetry400Poller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LROSADsDeleteAsyncRelativeRetry400Response struct {
	RawResponse *http.Response
}
type LROSADsDeleteAsyncRelativeRetryInvalidHeaderPollerResponse struct {
	Poller *LROSADsDeleteAsyncRelativeRetryInvalidHeaderPoller
	RawResponse *http.Response
}
func (l LROSADsDeleteAsyncRelativeRetryInvalidHeaderPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (LROSADsDeleteAsyncRelativeRetryInvalidHeaderResponse, error) {
	respType := LROSADsDeleteAsyncRelativeRetryInvalidHeaderResponse{}
	resp, err := l.Poller.pt.PollUntilDone(ctx, freq, nil)
	if err != nil {
		return respType, err
	}
	respType.RawResponse = resp
	return respType, nil
}
func (l *LROSADsDeleteAsyncRelativeRetryInvalidHeaderPollerResponse) Resume(ctx context.Context, client *LROSADsClient, token string) error {
	pt, err := armruntime.NewPollerFromResumeToken("LROSADsClient.DeleteAsyncRelativeRetryInvalidHeader", token, client.con.Pipeline(), client.deleteAsyncRelativeRetryInvalidHeaderHandleError)
	if err != nil {
		return err
	}
	poller := &LROSADsDeleteAsyncRelativeRetryInvalidHeaderPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return err
	}
	l.Poller = poller
	l.RawResponse = resp
	return nil
}
type LROSADsDeleteAsyncRelativeRetryInvalidHeaderResponse struct {
	RawResponse *http.Response
}
type LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingPollerResponse struct {
	Poller *LROSADsDeleteAsyncRelativeRetryInvalidJSONPollingPoller
	RawResponse *http.Response
}