func (client *HTTPClientFailureClient) options400CreateRequest(ctx context.Context, options *HTTPClientFailureOptions400Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/400"
	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
}
options400CreateRequest creates the Options400 request.
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 HTTPClientFailureClient struct {
	con *Connection
}
func NewHTTPClientFailureClient(con *Connection) *HTTPClientFailureClient {
	return &HTTPClientFailureClient{con: con}
}
func (client *HTTPClientFailureClient) Delete400(ctx context.Context, options *HTTPClientFailureDelete400Options) (HTTPClientFailureDelete400Response, error) {
	req, err := client.delete400CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureDelete400Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureDelete400Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureDelete400Response{}, client.delete400HandleError(resp)
	}
	return HTTPClientFailureDelete400Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) delete400CreateRequest(ctx context.Context, options *HTTPClientFailureDelete400Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/400"
	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 *HTTPClientFailureClient) delete400HandleError(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 *HTTPClientFailureClient) Delete407(ctx context.Context, options *HTTPClientFailureDelete407Options) (HTTPClientFailureDelete407Response, error) {
	req, err := client.delete407CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureDelete407Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureDelete407Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureDelete407Response{}, client.delete407HandleError(resp)
	}
	return HTTPClientFailureDelete407Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) delete407CreateRequest(ctx context.Context, options *HTTPClientFailureDelete407Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/407"
	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 *HTTPClientFailureClient) delete407HandleError(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 *HTTPClientFailureClient) Delete417(ctx context.Context, options *HTTPClientFailureDelete417Options) (HTTPClientFailureDelete417Response, error) {
	req, err := client.delete417CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureDelete417Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureDelete417Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureDelete417Response{}, client.delete417HandleError(resp)
	}
	return HTTPClientFailureDelete417Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) delete417CreateRequest(ctx context.Context, options *HTTPClientFailureDelete417Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/417"
	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 *HTTPClientFailureClient) delete417HandleError(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 *HTTPClientFailureClient) Get400(ctx context.Context, options *HTTPClientFailureGet400Options) (HTTPClientFailureGet400Response, error) {
	req, err := client.get400CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureGet400Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureGet400Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureGet400Response{}, client.get400HandleError(resp)
	}
	return HTTPClientFailureGet400Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) get400CreateRequest(ctx context.Context, options *HTTPClientFailureGet400Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/400"
	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 *HTTPClientFailureClient) get400HandleError(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 *HTTPClientFailureClient) Get402(ctx context.Context, options *HTTPClientFailureGet402Options) (HTTPClientFailureGet402Response, error) {
	req, err := client.get402CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureGet402Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureGet402Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureGet402Response{}, client.get402HandleError(resp)
	}
	return HTTPClientFailureGet402Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) get402CreateRequest(ctx context.Context, options *HTTPClientFailureGet402Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/402"
	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 *HTTPClientFailureClient) get402HandleError(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 *HTTPClientFailureClient) Get403(ctx context.Context, options *HTTPClientFailureGet403Options) (HTTPClientFailureGet403Response, error) {
	req, err := client.get403CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureGet403Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureGet403Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureGet403Response{}, client.get403HandleError(resp)
	}
	return HTTPClientFailureGet403Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) get403CreateRequest(ctx context.Context, options *HTTPClientFailureGet403Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/403"
	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 *HTTPClientFailureClient) get403HandleError(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 *HTTPClientFailureClient) Get411(ctx context.Context, options *HTTPClientFailureGet411Options) (HTTPClientFailureGet411Response, error) {
	req, err := client.get411CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureGet411Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureGet411Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureGet411Response{}, client.get411HandleError(resp)
	}
	return HTTPClientFailureGet411Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) get411CreateRequest(ctx context.Context, options *HTTPClientFailureGet411Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/411"
	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 *HTTPClientFailureClient) get411HandleError(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 *HTTPClientFailureClient) Get412(ctx context.Context, options *HTTPClientFailureGet412Options) (HTTPClientFailureGet412Response, error) {
	req, err := client.get412CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureGet412Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureGet412Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureGet412Response{}, client.get412HandleError(resp)
	}
	return HTTPClientFailureGet412Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) get412CreateRequest(ctx context.Context, options *HTTPClientFailureGet412Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/412"
	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 *HTTPClientFailureClient) get412HandleError(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 *HTTPClientFailureClient) Get416(ctx context.Context, options *HTTPClientFailureGet416Options) (HTTPClientFailureGet416Response, error) {
	req, err := client.get416CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureGet416Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureGet416Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureGet416Response{}, client.get416HandleError(resp)
	}
	return HTTPClientFailureGet416Response{RawResponse: resp}, nil
}
func (client *HTTPClientFailureClient) get416CreateRequest(ctx context.Context, options *HTTPClientFailureGet416Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/416"
	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 *HTTPClientFailureClient) get416HandleError(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 *HTTPClientFailureClient) Head400(ctx context.Context, options *HTTPClientFailureHead400Options) (HTTPClientFailureHead400Response, error) {
	req, err := client.head400CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureHead400Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureHead400Response{}, err
	}
	result := HTTPClientFailureHead400Response{RawResponse: resp}
	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
		result.Success = true
	}
	return result, nil
}
func (client *HTTPClientFailureClient) head400CreateRequest(ctx context.Context, options *HTTPClientFailureHead400Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/400"
	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 *HTTPClientFailureClient) Head401(ctx context.Context, options *HTTPClientFailureHead401Options) (HTTPClientFailureHead401Response, error) {
	req, err := client.head401CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureHead401Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureHead401Response{}, err
	}
	result := HTTPClientFailureHead401Response{RawResponse: resp}
	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
		result.Success = true
	}
	return result, nil
}
func (client *HTTPClientFailureClient) head401CreateRequest(ctx context.Context, options *HTTPClientFailureHead401Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/401"
	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 *HTTPClientFailureClient) Head410(ctx context.Context, options *HTTPClientFailureHead410Options) (HTTPClientFailureHead410Response, error) {
	req, err := client.head410CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureHead410Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureHead410Response{}, err
	}
	result := HTTPClientFailureHead410Response{RawResponse: resp}
	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
		result.Success = true
	}
	return result, nil
}
func (client *HTTPClientFailureClient) head410CreateRequest(ctx context.Context, options *HTTPClientFailureHead410Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/410"
	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 *HTTPClientFailureClient) Head429(ctx context.Context, options *HTTPClientFailureHead429Options) (HTTPClientFailureHead429Response, error) {
	req, err := client.head429CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureHead429Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureHead429Response{}, err
	}
	result := HTTPClientFailureHead429Response{RawResponse: resp}
	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
		result.Success = true
	}
	return result, nil
}
func (client *HTTPClientFailureClient) head429CreateRequest(ctx context.Context, options *HTTPClientFailureHead429Options) (*policy.Request, error) {
	urlPath := "/http/failure/client/429"
	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 *HTTPClientFailureClient) Options400(ctx context.Context, options *HTTPClientFailureOptions400Options) (HTTPClientFailureOptions400Response, error) {
	req, err := client.options400CreateRequest(ctx, options)
	if err != nil {
		return HTTPClientFailureOptions400Response{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return HTTPClientFailureOptions400Response{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent) {
		return HTTPClientFailureOptions400Response{}, client.options400HandleError(resp)
	}
	return HTTPClientFailureOptions400Response{RawResponse: resp}, nil
}