func (client *HTTPRetryClient) Patch504(ctx context.Context, options *HTTPRetryPatch504Options) (HTTPRetryPatch504Response, error) {
	req, err := client.patch504CreateRequest(ctx, options)
	if err != nil {
		return HTTPRetryPatch504Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPRetryPatch504Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return HTTPRetryPatch504Response{}, client.patch504HandleError(resp)
	}
	return HTTPRetryPatch504Response{RawResponse: resp}, nil
}
Patch504 - Return 504 status code, then 200 after retry
If the operation fails it returns the *Error error type.
package httpinfrastructuregroup
import (
	"context"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
)
type HTTPRetryClient struct {
	con *Connection
}
func NewHTTPRetryClient(con *Connection) *HTTPRetryClient {
	return &HTTPRetryClient{con: con}
}
func (client *HTTPRetryClient) Delete503(ctx context.Context, options *HTTPRetryDelete503Options) (HTTPRetryDelete503Response, error) {
	req, err := client.delete503CreateRequest(ctx, options)
	if err != nil {
		return HTTPRetryDelete503Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPRetryDelete503Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return HTTPRetryDelete503Response{}, client.delete503HandleError(resp)
	}
	return HTTPRetryDelete503Response{RawResponse: resp}, nil
}
func (client *HTTPRetryClient) delete503CreateRequest(ctx context.Context, options *HTTPRetryDelete503Options) (*policy.Request, error) {
	urlPath := "/http/retry/503"
	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, runtime.MarshalAsJSON(req, true)
}
func (client *HTTPRetryClient) delete503HandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{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 *HTTPRetryClient) Get502(ctx context.Context, options *HTTPRetryGet502Options) (HTTPRetryGet502Response, error) {
	req, err := client.get502CreateRequest(ctx, options)
	if err != nil {
		return HTTPRetryGet502Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPRetryGet502Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return HTTPRetryGet502Response{}, client.get502HandleError(resp)
	}
	return HTTPRetryGet502Response{RawResponse: resp}, nil
}
func (client *HTTPRetryClient) get502CreateRequest(ctx context.Context, options *HTTPRetryGet502Options) (*policy.Request, error) {
	urlPath := "/http/retry/502"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *HTTPRetryClient) get502HandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{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 *HTTPRetryClient) Head408(ctx context.Context, options *HTTPRetryHead408Options) (HTTPRetryHead408Response, error) {
	req, err := client.head408CreateRequest(ctx, options)
	if err != nil {
		return HTTPRetryHead408Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPRetryHead408Response{}, err
	}
	result := HTTPRetryHead408Response{RawResponse: resp}
	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
		result.Success = true
	}
	return result, nil
}
func (client *HTTPRetryClient) head408CreateRequest(ctx context.Context, options *HTTPRetryHead408Options) (*policy.Request, error) {
	urlPath := "/http/retry/408"
	req, err := runtime.NewRequest(ctx, http.MethodHead, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *HTTPRetryClient) Options502(ctx context.Context, options *HTTPRetryOptions502Options) (HTTPRetryOptions502Response, error) {
	req, err := client.options502CreateRequest(ctx, options)
	if err != nil {
		return HTTPRetryOptions502Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPRetryOptions502Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return HTTPRetryOptions502Response{}, client.options502HandleError(resp)
	}
	return client.options502HandleResponse(resp)
}
func (client *HTTPRetryClient) options502CreateRequest(ctx context.Context, options *HTTPRetryOptions502Options) (*policy.Request, error) {
	urlPath := "/http/retry/502"
	req, err := runtime.NewRequest(ctx, http.MethodOptions, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, nil
}
func (client *HTTPRetryClient) options502HandleResponse(resp *http.Response) (HTTPRetryOptions502Response, error) {
	result := HTTPRetryOptions502Response{RawResponse: resp}
	if err := runtime.UnmarshalAsJSON(resp, &result.Value); err != nil {
		return HTTPRetryOptions502Response{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *HTTPRetryClient) options502HandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{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 *HTTPRetryClient) Patch500(ctx context.Context, options *HTTPRetryPatch500Options) (HTTPRetryPatch500Response, error) {
	req, err := client.patch500CreateRequest(ctx, options)
	if err != nil {
		return HTTPRetryPatch500Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPRetryPatch500Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return HTTPRetryPatch500Response{}, client.patch500HandleError(resp)
	}
	return HTTPRetryPatch500Response{RawResponse: resp}, nil
}
func (client *HTTPRetryClient) patch500CreateRequest(ctx context.Context, options *HTTPRetryPatch500Options) (*policy.Request, error) {
	urlPath := "/http/retry/500"
	req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/json")
	return req, runtime.MarshalAsJSON(req, true)
}
func (client *HTTPRetryClient) patch500HandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{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)
}