func (client *LROsClient) BeginDeleteNoHeaderInRetry(ctx context.Context, options *LROsBeginDeleteNoHeaderInRetryOptions) (LROsDeleteNoHeaderInRetryPollerResponse, error) {
	resp, err := client.deleteNoHeaderInRetry(ctx, options)
	if err != nil {
		return LROsDeleteNoHeaderInRetryPollerResponse{}, err
	}
	result := LROsDeleteNoHeaderInRetryPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.DeleteNoHeaderInRetry", "", resp, client.con.Pipeline(), client.deleteNoHeaderInRetryHandleError)
	if err != nil {
		return LROsDeleteNoHeaderInRetryPollerResponse{}, err
	}
	result.Poller = &LROsDeleteNoHeaderInRetryPoller{
		pt: pt,
	}
	return result, nil
}
BeginDeleteNoHeaderInRetry - Long running delete request, service returns a location header in the initial request. Subsequent calls to operation status
do not contain location header.
If the operation fails it returns the *CloudError error type.
package lrogroup
import (
	"context"
	"fmt"
	armruntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm/runtime"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
)
type LROsClient struct {
	con *Connection
}
func NewLROsClient(con *Connection) *LROsClient {
	return &LROsClient{con: con}
}
func (client *LROsClient) BeginDelete202NoRetry204(ctx context.Context, options *LROsBeginDelete202NoRetry204Options) (LROsDelete202NoRetry204PollerResponse, error) {
	resp, err := client.delete202NoRetry204(ctx, options)
	if err != nil {
		return LROsDelete202NoRetry204PollerResponse{}, err
	}
	result := LROsDelete202NoRetry204PollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.Delete202NoRetry204", "", resp, client.con.Pipeline(), client.delete202NoRetry204HandleError)
	if err != nil {
		return LROsDelete202NoRetry204PollerResponse{}, err
	}
	result.Poller = &LROsDelete202NoRetry204Poller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) delete202NoRetry204(ctx context.Context, options *LROsBeginDelete202NoRetry204Options) (*http.Response, error) {
	req, err := client.delete202NoRetry204CreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusAccepted) {
		return nil, client.delete202NoRetry204HandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) delete202NoRetry204CreateRequest(ctx context.Context, options *LROsBeginDelete202NoRetry204Options) (*policy.Request, error) {
	urlPath := "/lro/delete/202/noretry/204"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) delete202NoRetry204HandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *LROsClient) BeginDelete202Retry200(ctx context.Context, options *LROsBeginDelete202Retry200Options) (LROsDelete202Retry200PollerResponse, error) {
	resp, err := client.delete202Retry200(ctx, options)
	if err != nil {
		return LROsDelete202Retry200PollerResponse{}, err
	}
	result := LROsDelete202Retry200PollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.Delete202Retry200", "", resp, client.con.Pipeline(), client.delete202Retry200HandleError)
	if err != nil {
		return LROsDelete202Retry200PollerResponse{}, err
	}
	result.Poller = &LROsDelete202Retry200Poller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) delete202Retry200(ctx context.Context, options *LROsBeginDelete202Retry200Options) (*http.Response, error) {
	req, err := client.delete202Retry200CreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusAccepted) {
		return nil, client.delete202Retry200HandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) delete202Retry200CreateRequest(ctx context.Context, options *LROsBeginDelete202Retry200Options) (*policy.Request, error) {
	urlPath := "/lro/delete/202/retry/200"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) delete202Retry200HandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *LROsClient) BeginDelete204Succeeded(ctx context.Context, options *LROsBeginDelete204SucceededOptions) (LROsDelete204SucceededPollerResponse, error) {
	resp, err := client.delete204Succeeded(ctx, options)
	if err != nil {
		return LROsDelete204SucceededPollerResponse{}, err
	}
	result := LROsDelete204SucceededPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.Delete204Succeeded", "", resp, client.con.Pipeline(), client.delete204SucceededHandleError)
	if err != nil {
		return LROsDelete204SucceededPollerResponse{}, err
	}
	result.Poller = &LROsDelete204SucceededPoller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) delete204Succeeded(ctx context.Context, options *LROsBeginDelete204SucceededOptions) (*http.Response, error) {
	req, err := client.delete204SucceededCreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusNoContent) {
		return nil, client.delete204SucceededHandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) delete204SucceededCreateRequest(ctx context.Context, options *LROsBeginDelete204SucceededOptions) (*policy.Request, error) {
	urlPath := "/lro/delete/204/succeeded"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) delete204SucceededHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *LROsClient) BeginDeleteAsyncNoHeaderInRetry(ctx context.Context, options *LROsBeginDeleteAsyncNoHeaderInRetryOptions) (LROsDeleteAsyncNoHeaderInRetryPollerResponse, error) {
	resp, err := client.deleteAsyncNoHeaderInRetry(ctx, options)
	if err != nil {
		return LROsDeleteAsyncNoHeaderInRetryPollerResponse{}, err
	}
	result := LROsDeleteAsyncNoHeaderInRetryPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.DeleteAsyncNoHeaderInRetry", "", resp, client.con.Pipeline(), client.deleteAsyncNoHeaderInRetryHandleError)
	if err != nil {
		return LROsDeleteAsyncNoHeaderInRetryPollerResponse{}, err
	}
	result.Poller = &LROsDeleteAsyncNoHeaderInRetryPoller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) deleteAsyncNoHeaderInRetry(ctx context.Context, options *LROsBeginDeleteAsyncNoHeaderInRetryOptions) (*http.Response, error) {
	req, err := client.deleteAsyncNoHeaderInRetryCreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusAccepted, http.StatusNoContent) {
		return nil, client.deleteAsyncNoHeaderInRetryHandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) deleteAsyncNoHeaderInRetryCreateRequest(ctx context.Context, options *LROsBeginDeleteAsyncNoHeaderInRetryOptions) (*policy.Request, error) {
	urlPath := "/lro/deleteasync/noheader/202/204"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) deleteAsyncNoHeaderInRetryHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *LROsClient) BeginDeleteAsyncNoRetrySucceeded(ctx context.Context, options *LROsBeginDeleteAsyncNoRetrySucceededOptions) (LROsDeleteAsyncNoRetrySucceededPollerResponse, error) {
	resp, err := client.deleteAsyncNoRetrySucceeded(ctx, options)
	if err != nil {
		return LROsDeleteAsyncNoRetrySucceededPollerResponse{}, err
	}
	result := LROsDeleteAsyncNoRetrySucceededPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.DeleteAsyncNoRetrySucceeded", "", resp, client.con.Pipeline(), client.deleteAsyncNoRetrySucceededHandleError)
	if err != nil {
		return LROsDeleteAsyncNoRetrySucceededPollerResponse{}, err
	}
	result.Poller = &LROsDeleteAsyncNoRetrySucceededPoller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) deleteAsyncNoRetrySucceeded(ctx context.Context, options *LROsBeginDeleteAsyncNoRetrySucceededOptions) (*http.Response, error) {
	req, err := client.deleteAsyncNoRetrySucceededCreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusAccepted) {
		return nil, client.deleteAsyncNoRetrySucceededHandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) deleteAsyncNoRetrySucceededCreateRequest(ctx context.Context, options *LROsBeginDeleteAsyncNoRetrySucceededOptions) (*policy.Request, error) {
	urlPath := "/lro/deleteasync/noretry/succeeded"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) deleteAsyncNoRetrySucceededHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *LROsClient) BeginDeleteAsyncRetryFailed(ctx context.Context, options *LROsBeginDeleteAsyncRetryFailedOptions) (LROsDeleteAsyncRetryFailedPollerResponse, error) {
	resp, err := client.deleteAsyncRetryFailed(ctx, options)
	if err != nil {
		return LROsDeleteAsyncRetryFailedPollerResponse{}, err
	}
	result := LROsDeleteAsyncRetryFailedPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.DeleteAsyncRetryFailed", "", resp, client.con.Pipeline(), client.deleteAsyncRetryFailedHandleError)
	if err != nil {
		return LROsDeleteAsyncRetryFailedPollerResponse{}, err
	}
	result.Poller = &LROsDeleteAsyncRetryFailedPoller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) deleteAsyncRetryFailed(ctx context.Context, options *LROsBeginDeleteAsyncRetryFailedOptions) (*http.Response, error) {
	req, err := client.deleteAsyncRetryFailedCreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusAccepted) {
		return nil, client.deleteAsyncRetryFailedHandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) deleteAsyncRetryFailedCreateRequest(ctx context.Context, options *LROsBeginDeleteAsyncRetryFailedOptions) (*policy.Request, error) {
	urlPath := "/lro/deleteasync/retry/failed"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) deleteAsyncRetryFailedHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *LROsClient) BeginDeleteAsyncRetrySucceeded(ctx context.Context, options *LROsBeginDeleteAsyncRetrySucceededOptions) (LROsDeleteAsyncRetrySucceededPollerResponse, error) {
	resp, err := client.deleteAsyncRetrySucceeded(ctx, options)
	if err != nil {
		return LROsDeleteAsyncRetrySucceededPollerResponse{}, err
	}
	result := LROsDeleteAsyncRetrySucceededPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.DeleteAsyncRetrySucceeded", "", resp, client.con.Pipeline(), client.deleteAsyncRetrySucceededHandleError)
	if err != nil {
		return LROsDeleteAsyncRetrySucceededPollerResponse{}, err
	}
	result.Poller = &LROsDeleteAsyncRetrySucceededPoller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) deleteAsyncRetrySucceeded(ctx context.Context, options *LROsBeginDeleteAsyncRetrySucceededOptions) (*http.Response, error) {
	req, err := client.deleteAsyncRetrySucceededCreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusAccepted) {
		return nil, client.deleteAsyncRetrySucceededHandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) deleteAsyncRetrySucceededCreateRequest(ctx context.Context, options *LROsBeginDeleteAsyncRetrySucceededOptions) (*policy.Request, error) {
	urlPath := "/lro/deleteasync/retry/succeeded"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) deleteAsyncRetrySucceededHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *LROsClient) BeginDeleteAsyncRetrycanceled(ctx context.Context, options *LROsBeginDeleteAsyncRetrycanceledOptions) (LROsDeleteAsyncRetrycanceledPollerResponse, error) {
	resp, err := client.deleteAsyncRetrycanceled(ctx, options)
	if err != nil {
		return LROsDeleteAsyncRetrycanceledPollerResponse{}, err
	}
	result := LROsDeleteAsyncRetrycanceledPollerResponse{
		RawResponse: resp,
	}
	pt, err := armruntime.NewPoller("LROsClient.DeleteAsyncRetrycanceled", "", resp, client.con.Pipeline(), client.deleteAsyncRetrycanceledHandleError)
	if err != nil {
		return LROsDeleteAsyncRetrycanceledPollerResponse{}, err
	}
	result.Poller = &LROsDeleteAsyncRetrycanceledPoller{
		pt: pt,
	}
	return result, nil
}
func (client *LROsClient) deleteAsyncRetrycanceled(ctx context.Context, options *LROsBeginDeleteAsyncRetrycanceledOptions) (*http.Response, error) {
	req, err := client.deleteAsyncRetrycanceledCreateRequest(ctx, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !runtime.HasStatusCode(resp, http.StatusAccepted) {
		return nil, client.deleteAsyncRetrycanceledHandleError(resp)
	}
	return resp, nil
}
func (client *LROsClient) deleteAsyncRetrycanceledCreateRequest(ctx context.Context, options *LROsBeginDeleteAsyncRetrycanceledOptions) (*policy.Request, error) {
	urlPath := "/lro/deleteasync/retry/canceled"
	req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *LROsClient) deleteAsyncRetrycanceledHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := CloudError{raw: string(body)}
	if err := runtime.UnmarshalAsJSON(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}