errors.go

// Automatically generated by gen_errors.go

/*
Copyright 2017 The Nuclio Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package nuclio

import (
	"errors"
	"fmt"
	"net/http"
)

// WithStatusCode is an error with status code
type WithStatusCode interface {
	StatusCode() int
}

// ErrorWithStatusCode implements both error and WithStatusCode
type ErrorWithStatusCode struct {
	error
	statusCode int
}

// GetError returns the underlying error
func (e *ErrorWithStatusCode) GetError() error {
	return e.error
}

// StatusCode returns the status code
func (e *ErrorWithStatusCode) StatusCode() int {
	return e.statusCode
}

// Error returns the error message
func (e ErrorWithStatusCode) Error() string {
	if e.error != nil {
		return e.error.Error()
	}

	message, ok := defaultMessages[e.statusCode]
	if !ok {
		message = fmt.Sprintf("Unknown error: %d", e.statusCode)
	}

	return message
}

// ErrAccepted is a StatusAccepted Error
var ErrAccepted = ErrorWithStatusCode{statusCode: http.StatusAccepted}

// NewErrAccepted returns a new ErrAccepted with custom error message
func NewErrAccepted(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusAccepted,
	}
}

// WrapErrAccepted returns a new ErrAccepted, wrapping an existing error
func WrapErrAccepted(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusAccepted,
	}
}

// ErrAlreadyReported is a StatusAlreadyReported Error
var ErrAlreadyReported = ErrorWithStatusCode{statusCode: http.StatusAlreadyReported}

// NewErrAlreadyReported returns a new ErrAlreadyReported with custom error message
func NewErrAlreadyReported(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusAlreadyReported,
	}
}

// WrapErrAlreadyReported returns a new ErrAlreadyReported, wrapping an existing error
func WrapErrAlreadyReported(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusAlreadyReported,
	}
}

// ErrBadGateway is a StatusBadGateway Error
var ErrBadGateway = ErrorWithStatusCode{statusCode: http.StatusBadGateway}

// NewErrBadGateway returns a new ErrBadGateway with custom error message
func NewErrBadGateway(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusBadGateway,
	}
}

// WrapErrBadGateway returns a new ErrBadGateway, wrapping an existing error
func WrapErrBadGateway(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusBadGateway,
	}
}

// ErrBadRequest is a StatusBadRequest Error
var ErrBadRequest = ErrorWithStatusCode{statusCode: http.StatusBadRequest}

// NewErrBadRequest returns a new ErrBadRequest with custom error message
func NewErrBadRequest(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusBadRequest,
	}
}

// WrapErrBadRequest returns a new ErrBadRequest, wrapping an existing error
func WrapErrBadRequest(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusBadRequest,
	}
}

// ErrConflict is a StatusConflict Error
var ErrConflict = ErrorWithStatusCode{statusCode: http.StatusConflict}

// NewErrConflict returns a new ErrConflict with custom error message
func NewErrConflict(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusConflict,
	}
}

// WrapErrConflict returns a new ErrConflict, wrapping an existing error
func WrapErrConflict(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusConflict,
	}
}

// ErrContinue is a StatusContinue Error
var ErrContinue = ErrorWithStatusCode{statusCode: http.StatusContinue}

// NewErrContinue returns a new ErrContinue with custom error message
func NewErrContinue(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusContinue,
	}
}

// WrapErrContinue returns a new ErrContinue, wrapping an existing error
func WrapErrContinue(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusContinue,
	}
}

// ErrCreated is a StatusCreated Error
var ErrCreated = ErrorWithStatusCode{statusCode: http.StatusCreated}

// NewErrCreated returns a new ErrCreated with custom error message
func NewErrCreated(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusCreated,
	}
}

// WrapErrCreated returns a new ErrCreated, wrapping an existing error
func WrapErrCreated(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusCreated,
	}
}

// ErrEarlyHints is a StatusEarlyHints Error
var ErrEarlyHints = ErrorWithStatusCode{statusCode: http.StatusEarlyHints}

// NewErrEarlyHints returns a new ErrEarlyHints with custom error message
func NewErrEarlyHints(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusEarlyHints,
	}
}

// WrapErrEarlyHints returns a new ErrEarlyHints, wrapping an existing error
func WrapErrEarlyHints(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusEarlyHints,
	}
}

// ErrExpectationFailed is a StatusExpectationFailed Error
var ErrExpectationFailed = ErrorWithStatusCode{statusCode: http.StatusExpectationFailed}

// NewErrExpectationFailed returns a new ErrExpectationFailed with custom error message
func NewErrExpectationFailed(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusExpectationFailed,
	}
}

// WrapErrExpectationFailed returns a new ErrExpectationFailed, wrapping an existing error
func WrapErrExpectationFailed(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusExpectationFailed,
	}
}

// ErrFailedDependency is a StatusFailedDependency Error
var ErrFailedDependency = ErrorWithStatusCode{statusCode: http.StatusFailedDependency}

// NewErrFailedDependency returns a new ErrFailedDependency with custom error message
func NewErrFailedDependency(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusFailedDependency,
	}
}

// WrapErrFailedDependency returns a new ErrFailedDependency, wrapping an existing error
func WrapErrFailedDependency(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusFailedDependency,
	}
}

// ErrForbidden is a StatusForbidden Error
var ErrForbidden = ErrorWithStatusCode{statusCode: http.StatusForbidden}

// NewErrForbidden returns a new ErrForbidden with custom error message
func NewErrForbidden(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusForbidden,
	}
}

// WrapErrForbidden returns a new ErrForbidden, wrapping an existing error
func WrapErrForbidden(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusForbidden,
	}
}

// ErrFound is a StatusFound Error
var ErrFound = ErrorWithStatusCode{statusCode: http.StatusFound}

// NewErrFound returns a new ErrFound with custom error message
func NewErrFound(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusFound,
	}
}

// WrapErrFound returns a new ErrFound, wrapping an existing error
func WrapErrFound(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusFound,
	}
}

// ErrGatewayTimeout is a StatusGatewayTimeout Error
var ErrGatewayTimeout = ErrorWithStatusCode{statusCode: http.StatusGatewayTimeout}

// NewErrGatewayTimeout returns a new ErrGatewayTimeout with custom error message
func NewErrGatewayTimeout(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusGatewayTimeout,
	}
}

// WrapErrGatewayTimeout returns a new ErrGatewayTimeout, wrapping an existing error
func WrapErrGatewayTimeout(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusGatewayTimeout,
	}
}

// ErrGone is a StatusGone Error
var ErrGone = ErrorWithStatusCode{statusCode: http.StatusGone}

// NewErrGone returns a new ErrGone with custom error message
func NewErrGone(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusGone,
	}
}

// WrapErrGone returns a new ErrGone, wrapping an existing error
func WrapErrGone(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusGone,
	}
}

// ErrHTTPVersionNotSupported is a StatusHTTPVersionNotSupported Error
var ErrHTTPVersionNotSupported = ErrorWithStatusCode{statusCode: http.StatusHTTPVersionNotSupported}

// NewErrHTTPVersionNotSupported returns a new ErrHTTPVersionNotSupported with custom error message
func NewErrHTTPVersionNotSupported(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusHTTPVersionNotSupported,
	}
}

// WrapErrHTTPVersionNotSupported returns a new ErrHTTPVersionNotSupported, wrapping an existing error
func WrapErrHTTPVersionNotSupported(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusHTTPVersionNotSupported,
	}
}

// ErrIMUsed is a StatusIMUsed Error
var ErrIMUsed = ErrorWithStatusCode{statusCode: http.StatusIMUsed}

// NewErrIMUsed returns a new ErrIMUsed with custom error message
func NewErrIMUsed(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusIMUsed,
	}
}

// WrapErrIMUsed returns a new ErrIMUsed, wrapping an existing error
func WrapErrIMUsed(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusIMUsed,
	}
}

// ErrInsufficientStorage is a StatusInsufficientStorage Error
var ErrInsufficientStorage = ErrorWithStatusCode{statusCode: http.StatusInsufficientStorage}

// NewErrInsufficientStorage returns a new ErrInsufficientStorage with custom error message
func NewErrInsufficientStorage(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusInsufficientStorage,
	}
}

// WrapErrInsufficientStorage returns a new ErrInsufficientStorage, wrapping an existing error
func WrapErrInsufficientStorage(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusInsufficientStorage,
	}
}

// ErrInternalServerError is a StatusInternalServerError Error
var ErrInternalServerError = ErrorWithStatusCode{statusCode: http.StatusInternalServerError}

// NewErrInternalServerError returns a new ErrInternalServerError with custom error message
func NewErrInternalServerError(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusInternalServerError,
	}
}

// WrapErrInternalServerError returns a new ErrInternalServerError, wrapping an existing error
func WrapErrInternalServerError(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusInternalServerError,
	}
}

// ErrLengthRequired is a StatusLengthRequired Error
var ErrLengthRequired = ErrorWithStatusCode{statusCode: http.StatusLengthRequired}

// NewErrLengthRequired returns a new ErrLengthRequired with custom error message
func NewErrLengthRequired(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusLengthRequired,
	}
}

// WrapErrLengthRequired returns a new ErrLengthRequired, wrapping an existing error
func WrapErrLengthRequired(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusLengthRequired,
	}
}

// ErrLocked is a StatusLocked Error
var ErrLocked = ErrorWithStatusCode{statusCode: http.StatusLocked}

// NewErrLocked returns a new ErrLocked with custom error message
func NewErrLocked(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusLocked,
	}
}

// WrapErrLocked returns a new ErrLocked, wrapping an existing error
func WrapErrLocked(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusLocked,
	}
}

// ErrLoopDetected is a StatusLoopDetected Error
var ErrLoopDetected = ErrorWithStatusCode{statusCode: http.StatusLoopDetected}

// NewErrLoopDetected returns a new ErrLoopDetected with custom error message
func NewErrLoopDetected(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusLoopDetected,
	}
}

// WrapErrLoopDetected returns a new ErrLoopDetected, wrapping an existing error
func WrapErrLoopDetected(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusLoopDetected,
	}
}

// ErrMethodNotAllowed is a StatusMethodNotAllowed Error
var ErrMethodNotAllowed = ErrorWithStatusCode{statusCode: http.StatusMethodNotAllowed}

// NewErrMethodNotAllowed returns a new ErrMethodNotAllowed with custom error message
func NewErrMethodNotAllowed(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusMethodNotAllowed,
	}
}

// WrapErrMethodNotAllowed returns a new ErrMethodNotAllowed, wrapping an existing error
func WrapErrMethodNotAllowed(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusMethodNotAllowed,
	}
}

// ErrMisdirectedRequest is a StatusMisdirectedRequest Error
var ErrMisdirectedRequest = ErrorWithStatusCode{statusCode: http.StatusMisdirectedRequest}

// NewErrMisdirectedRequest returns a new ErrMisdirectedRequest with custom error message
func NewErrMisdirectedRequest(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusMisdirectedRequest,
	}
}

// WrapErrMisdirectedRequest returns a new ErrMisdirectedRequest, wrapping an existing error
func WrapErrMisdirectedRequest(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusMisdirectedRequest,
	}
}

// ErrMovedPermanently is a StatusMovedPermanently Error
var ErrMovedPermanently = ErrorWithStatusCode{statusCode: http.StatusMovedPermanently}

// NewErrMovedPermanently returns a new ErrMovedPermanently with custom error message
func NewErrMovedPermanently(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusMovedPermanently,
	}
}

// WrapErrMovedPermanently returns a new ErrMovedPermanently, wrapping an existing error
func WrapErrMovedPermanently(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusMovedPermanently,
	}
}

// ErrMultiStatus is a StatusMultiStatus Error
var ErrMultiStatus = ErrorWithStatusCode{statusCode: http.StatusMultiStatus}

// NewErrMultiStatus returns a new ErrMultiStatus with custom error message
func NewErrMultiStatus(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusMultiStatus,
	}
}

// WrapErrMultiStatus returns a new ErrMultiStatus, wrapping an existing error
func WrapErrMultiStatus(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusMultiStatus,
	}
}

// ErrMultipleChoices is a StatusMultipleChoices Error
var ErrMultipleChoices = ErrorWithStatusCode{statusCode: http.StatusMultipleChoices}

// NewErrMultipleChoices returns a new ErrMultipleChoices with custom error message
func NewErrMultipleChoices(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusMultipleChoices,
	}
}

// WrapErrMultipleChoices returns a new ErrMultipleChoices, wrapping an existing error
func WrapErrMultipleChoices(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusMultipleChoices,
	}
}

// ErrNetworkAuthenticationRequired is a StatusNetworkAuthenticationRequired Error
var ErrNetworkAuthenticationRequired = ErrorWithStatusCode{statusCode: http.StatusNetworkAuthenticationRequired}

// NewErrNetworkAuthenticationRequired returns a new ErrNetworkAuthenticationRequired with custom error message
func NewErrNetworkAuthenticationRequired(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNetworkAuthenticationRequired,
	}
}

// WrapErrNetworkAuthenticationRequired returns a new ErrNetworkAuthenticationRequired, wrapping an existing error
func WrapErrNetworkAuthenticationRequired(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNetworkAuthenticationRequired,
	}
}

// ErrNoContent is a StatusNoContent Error
var ErrNoContent = ErrorWithStatusCode{statusCode: http.StatusNoContent}

// NewErrNoContent returns a new ErrNoContent with custom error message
func NewErrNoContent(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNoContent,
	}
}

// WrapErrNoContent returns a new ErrNoContent, wrapping an existing error
func WrapErrNoContent(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNoContent,
	}
}

// ErrNonAuthoritativeInfo is a StatusNonAuthoritativeInfo Error
var ErrNonAuthoritativeInfo = ErrorWithStatusCode{statusCode: http.StatusNonAuthoritativeInfo}

// NewErrNonAuthoritativeInfo returns a new ErrNonAuthoritativeInfo with custom error message
func NewErrNonAuthoritativeInfo(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNonAuthoritativeInfo,
	}
}

// WrapErrNonAuthoritativeInfo returns a new ErrNonAuthoritativeInfo, wrapping an existing error
func WrapErrNonAuthoritativeInfo(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNonAuthoritativeInfo,
	}
}

// ErrNotAcceptable is a StatusNotAcceptable Error
var ErrNotAcceptable = ErrorWithStatusCode{statusCode: http.StatusNotAcceptable}

// NewErrNotAcceptable returns a new ErrNotAcceptable with custom error message
func NewErrNotAcceptable(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNotAcceptable,
	}
}

// WrapErrNotAcceptable returns a new ErrNotAcceptable, wrapping an existing error
func WrapErrNotAcceptable(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNotAcceptable,
	}
}

// ErrNotExtended is a StatusNotExtended Error
var ErrNotExtended = ErrorWithStatusCode{statusCode: http.StatusNotExtended}

// NewErrNotExtended returns a new ErrNotExtended with custom error message
func NewErrNotExtended(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNotExtended,
	}
}

// WrapErrNotExtended returns a new ErrNotExtended, wrapping an existing error
func WrapErrNotExtended(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNotExtended,
	}
}

// ErrNotFound is a StatusNotFound Error
var ErrNotFound = ErrorWithStatusCode{statusCode: http.StatusNotFound}

// NewErrNotFound returns a new ErrNotFound with custom error message
func NewErrNotFound(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNotFound,
	}
}

// WrapErrNotFound returns a new ErrNotFound, wrapping an existing error
func WrapErrNotFound(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNotFound,
	}
}

// ErrNotImplemented is a StatusNotImplemented Error
var ErrNotImplemented = ErrorWithStatusCode{statusCode: http.StatusNotImplemented}

// NewErrNotImplemented returns a new ErrNotImplemented with custom error message
func NewErrNotImplemented(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNotImplemented,
	}
}

// WrapErrNotImplemented returns a new ErrNotImplemented, wrapping an existing error
func WrapErrNotImplemented(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNotImplemented,
	}
}

// ErrNotModified is a StatusNotModified Error
var ErrNotModified = ErrorWithStatusCode{statusCode: http.StatusNotModified}

// NewErrNotModified returns a new ErrNotModified with custom error message
func NewErrNotModified(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusNotModified,
	}
}

// WrapErrNotModified returns a new ErrNotModified, wrapping an existing error
func WrapErrNotModified(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusNotModified,
	}
}

// ErrPartialContent is a StatusPartialContent Error
var ErrPartialContent = ErrorWithStatusCode{statusCode: http.StatusPartialContent}

// NewErrPartialContent returns a new ErrPartialContent with custom error message
func NewErrPartialContent(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusPartialContent,
	}
}

// WrapErrPartialContent returns a new ErrPartialContent, wrapping an existing error
func WrapErrPartialContent(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusPartialContent,
	}
}

// ErrPaymentRequired is a StatusPaymentRequired Error
var ErrPaymentRequired = ErrorWithStatusCode{statusCode: http.StatusPaymentRequired}

// NewErrPaymentRequired returns a new ErrPaymentRequired with custom error message
func NewErrPaymentRequired(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusPaymentRequired,
	}
}

// WrapErrPaymentRequired returns a new ErrPaymentRequired, wrapping an existing error
func WrapErrPaymentRequired(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusPaymentRequired,
	}
}

// ErrPermanentRedirect is a StatusPermanentRedirect Error
var ErrPermanentRedirect = ErrorWithStatusCode{statusCode: http.StatusPermanentRedirect}

// NewErrPermanentRedirect returns a new ErrPermanentRedirect with custom error message
func NewErrPermanentRedirect(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusPermanentRedirect,
	}
}

// WrapErrPermanentRedirect returns a new ErrPermanentRedirect, wrapping an existing error
func WrapErrPermanentRedirect(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusPermanentRedirect,
	}
}

// ErrPreconditionFailed is a StatusPreconditionFailed Error
var ErrPreconditionFailed = ErrorWithStatusCode{statusCode: http.StatusPreconditionFailed}

// NewErrPreconditionFailed returns a new ErrPreconditionFailed with custom error message
func NewErrPreconditionFailed(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusPreconditionFailed,
	}
}

// WrapErrPreconditionFailed returns a new ErrPreconditionFailed, wrapping an existing error
func WrapErrPreconditionFailed(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusPreconditionFailed,
	}
}

// ErrPreconditionRequired is a StatusPreconditionRequired Error
var ErrPreconditionRequired = ErrorWithStatusCode{statusCode: http.StatusPreconditionRequired}

// NewErrPreconditionRequired returns a new ErrPreconditionRequired with custom error message
func NewErrPreconditionRequired(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusPreconditionRequired,
	}
}

// WrapErrPreconditionRequired returns a new ErrPreconditionRequired, wrapping an existing error
func WrapErrPreconditionRequired(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusPreconditionRequired,
	}
}

// ErrProcessing is a StatusProcessing Error
var ErrProcessing = ErrorWithStatusCode{statusCode: http.StatusProcessing}

// NewErrProcessing returns a new ErrProcessing with custom error message
func NewErrProcessing(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusProcessing,
	}
}

// WrapErrProcessing returns a new ErrProcessing, wrapping an existing error
func WrapErrProcessing(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusProcessing,
	}
}

// ErrProxyAuthRequired is a StatusProxyAuthRequired Error
var ErrProxyAuthRequired = ErrorWithStatusCode{statusCode: http.StatusProxyAuthRequired}

// NewErrProxyAuthRequired returns a new ErrProxyAuthRequired with custom error message
func NewErrProxyAuthRequired(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusProxyAuthRequired,
	}
}

// WrapErrProxyAuthRequired returns a new ErrProxyAuthRequired, wrapping an existing error
func WrapErrProxyAuthRequired(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusProxyAuthRequired,
	}
}

// ErrRequestEntityTooLarge is a StatusRequestEntityTooLarge Error
var ErrRequestEntityTooLarge = ErrorWithStatusCode{statusCode: http.StatusRequestEntityTooLarge}

// NewErrRequestEntityTooLarge returns a new ErrRequestEntityTooLarge with custom error message
func NewErrRequestEntityTooLarge(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusRequestEntityTooLarge,
	}
}

// WrapErrRequestEntityTooLarge returns a new ErrRequestEntityTooLarge, wrapping an existing error
func WrapErrRequestEntityTooLarge(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusRequestEntityTooLarge,
	}
}

// ErrRequestHeaderFieldsTooLarge is a StatusRequestHeaderFieldsTooLarge Error
var ErrRequestHeaderFieldsTooLarge = ErrorWithStatusCode{statusCode: http.StatusRequestHeaderFieldsTooLarge}

// NewErrRequestHeaderFieldsTooLarge returns a new ErrRequestHeaderFieldsTooLarge with custom error message
func NewErrRequestHeaderFieldsTooLarge(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusRequestHeaderFieldsTooLarge,
	}
}

// WrapErrRequestHeaderFieldsTooLarge returns a new ErrRequestHeaderFieldsTooLarge, wrapping an existing error
func WrapErrRequestHeaderFieldsTooLarge(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusRequestHeaderFieldsTooLarge,
	}
}

// ErrRequestTimeout is a StatusRequestTimeout Error
var ErrRequestTimeout = ErrorWithStatusCode{statusCode: http.StatusRequestTimeout}

// NewErrRequestTimeout returns a new ErrRequestTimeout with custom error message
func NewErrRequestTimeout(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusRequestTimeout,
	}
}

// WrapErrRequestTimeout returns a new ErrRequestTimeout, wrapping an existing error
func WrapErrRequestTimeout(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusRequestTimeout,
	}
}

// ErrRequestURITooLong is a StatusRequestURITooLong Error
var ErrRequestURITooLong = ErrorWithStatusCode{statusCode: http.StatusRequestURITooLong}

// NewErrRequestURITooLong returns a new ErrRequestURITooLong with custom error message
func NewErrRequestURITooLong(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusRequestURITooLong,
	}
}

// WrapErrRequestURITooLong returns a new ErrRequestURITooLong, wrapping an existing error
func WrapErrRequestURITooLong(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusRequestURITooLong,
	}
}

// ErrRequestedRangeNotSatisfiable is a StatusRequestedRangeNotSatisfiable Error
var ErrRequestedRangeNotSatisfiable = ErrorWithStatusCode{statusCode: http.StatusRequestedRangeNotSatisfiable}

// NewErrRequestedRangeNotSatisfiable returns a new ErrRequestedRangeNotSatisfiable with custom error message
func NewErrRequestedRangeNotSatisfiable(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusRequestedRangeNotSatisfiable,
	}
}

// WrapErrRequestedRangeNotSatisfiable returns a new ErrRequestedRangeNotSatisfiable, wrapping an existing error
func WrapErrRequestedRangeNotSatisfiable(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusRequestedRangeNotSatisfiable,
	}
}

// ErrResetContent is a StatusResetContent Error
var ErrResetContent = ErrorWithStatusCode{statusCode: http.StatusResetContent}

// NewErrResetContent returns a new ErrResetContent with custom error message
func NewErrResetContent(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusResetContent,
	}
}

// WrapErrResetContent returns a new ErrResetContent, wrapping an existing error
func WrapErrResetContent(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusResetContent,
	}
}

// ErrSeeOther is a StatusSeeOther Error
var ErrSeeOther = ErrorWithStatusCode{statusCode: http.StatusSeeOther}

// NewErrSeeOther returns a new ErrSeeOther with custom error message
func NewErrSeeOther(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusSeeOther,
	}
}

// WrapErrSeeOther returns a new ErrSeeOther, wrapping an existing error
func WrapErrSeeOther(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusSeeOther,
	}
}

// ErrServiceUnavailable is a StatusServiceUnavailable Error
var ErrServiceUnavailable = ErrorWithStatusCode{statusCode: http.StatusServiceUnavailable}

// NewErrServiceUnavailable returns a new ErrServiceUnavailable with custom error message
func NewErrServiceUnavailable(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusServiceUnavailable,
	}
}

// WrapErrServiceUnavailable returns a new ErrServiceUnavailable, wrapping an existing error
func WrapErrServiceUnavailable(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusServiceUnavailable,
	}
}

// ErrSwitchingProtocols is a StatusSwitchingProtocols Error
var ErrSwitchingProtocols = ErrorWithStatusCode{statusCode: http.StatusSwitchingProtocols}

// NewErrSwitchingProtocols returns a new ErrSwitchingProtocols with custom error message
func NewErrSwitchingProtocols(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusSwitchingProtocols,
	}
}

// WrapErrSwitchingProtocols returns a new ErrSwitchingProtocols, wrapping an existing error
func WrapErrSwitchingProtocols(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusSwitchingProtocols,
	}
}

// ErrTeapot is a StatusTeapot Error
var ErrTeapot = ErrorWithStatusCode{statusCode: http.StatusTeapot}

// NewErrTeapot returns a new ErrTeapot with custom error message
func NewErrTeapot(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusTeapot,
	}
}

// WrapErrTeapot returns a new ErrTeapot, wrapping an existing error
func WrapErrTeapot(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusTeapot,
	}
}

// ErrTemporaryRedirect is a StatusTemporaryRedirect Error
var ErrTemporaryRedirect = ErrorWithStatusCode{statusCode: http.StatusTemporaryRedirect}

// NewErrTemporaryRedirect returns a new ErrTemporaryRedirect with custom error message
func NewErrTemporaryRedirect(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusTemporaryRedirect,
	}
}

// WrapErrTemporaryRedirect returns a new ErrTemporaryRedirect, wrapping an existing error
func WrapErrTemporaryRedirect(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusTemporaryRedirect,
	}
}

// ErrTooEarly is a StatusTooEarly Error
var ErrTooEarly = ErrorWithStatusCode{statusCode: http.StatusTooEarly}

// NewErrTooEarly returns a new ErrTooEarly with custom error message
func NewErrTooEarly(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusTooEarly,
	}
}

// WrapErrTooEarly returns a new ErrTooEarly, wrapping an existing error
func WrapErrTooEarly(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusTooEarly,
	}
}

// ErrTooManyRequests is a StatusTooManyRequests Error
var ErrTooManyRequests = ErrorWithStatusCode{statusCode: http.StatusTooManyRequests}

// NewErrTooManyRequests returns a new ErrTooManyRequests with custom error message
func NewErrTooManyRequests(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusTooManyRequests,
	}
}

// WrapErrTooManyRequests returns a new ErrTooManyRequests, wrapping an existing error
func WrapErrTooManyRequests(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusTooManyRequests,
	}
}

// ErrUnauthorized is a StatusUnauthorized Error
var ErrUnauthorized = ErrorWithStatusCode{statusCode: http.StatusUnauthorized}

// NewErrUnauthorized returns a new ErrUnauthorized with custom error message
func NewErrUnauthorized(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusUnauthorized,
	}
}

// WrapErrUnauthorized returns a new ErrUnauthorized, wrapping an existing error
func WrapErrUnauthorized(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusUnauthorized,
	}
}

// ErrUnavailableForLegalReasons is a StatusUnavailableForLegalReasons Error
var ErrUnavailableForLegalReasons = ErrorWithStatusCode{statusCode: http.StatusUnavailableForLegalReasons}

// NewErrUnavailableForLegalReasons returns a new ErrUnavailableForLegalReasons with custom error message
func NewErrUnavailableForLegalReasons(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusUnavailableForLegalReasons,
	}
}

// WrapErrUnavailableForLegalReasons returns a new ErrUnavailableForLegalReasons, wrapping an existing error
func WrapErrUnavailableForLegalReasons(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusUnavailableForLegalReasons,
	}
}

// ErrUnprocessableEntity is a StatusUnprocessableEntity Error
var ErrUnprocessableEntity = ErrorWithStatusCode{statusCode: http.StatusUnprocessableEntity}

// NewErrUnprocessableEntity returns a new ErrUnprocessableEntity with custom error message
func NewErrUnprocessableEntity(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusUnprocessableEntity,
	}
}

// WrapErrUnprocessableEntity returns a new ErrUnprocessableEntity, wrapping an existing error
func WrapErrUnprocessableEntity(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusUnprocessableEntity,
	}
}

// ErrUnsupportedMediaType is a StatusUnsupportedMediaType Error
var ErrUnsupportedMediaType = ErrorWithStatusCode{statusCode: http.StatusUnsupportedMediaType}

// NewErrUnsupportedMediaType returns a new ErrUnsupportedMediaType with custom error message
func NewErrUnsupportedMediaType(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusUnsupportedMediaType,
	}
}

// WrapErrUnsupportedMediaType returns a new ErrUnsupportedMediaType, wrapping an existing error
func WrapErrUnsupportedMediaType(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusUnsupportedMediaType,
	}
}

// ErrUpgradeRequired is a StatusUpgradeRequired Error
var ErrUpgradeRequired = ErrorWithStatusCode{statusCode: http.StatusUpgradeRequired}

// NewErrUpgradeRequired returns a new ErrUpgradeRequired with custom error message
func NewErrUpgradeRequired(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusUpgradeRequired,
	}
}

// WrapErrUpgradeRequired returns a new ErrUpgradeRequired, wrapping an existing error
func WrapErrUpgradeRequired(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusUpgradeRequired,
	}
}

// ErrUseProxy is a StatusUseProxy Error
var ErrUseProxy = ErrorWithStatusCode{statusCode: http.StatusUseProxy}

// NewErrUseProxy returns a new ErrUseProxy with custom error message
func NewErrUseProxy(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusUseProxy,
	}
}

// WrapErrUseProxy returns a new ErrUseProxy, wrapping an existing error
func WrapErrUseProxy(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusUseProxy,
	}
}

// ErrVariantAlsoNegotiates is a StatusVariantAlsoNegotiates Error
var ErrVariantAlsoNegotiates = ErrorWithStatusCode{statusCode: http.StatusVariantAlsoNegotiates}

// NewErrVariantAlsoNegotiates returns a new ErrVariantAlsoNegotiates with custom error message
func NewErrVariantAlsoNegotiates(message string) error {
	return &ErrorWithStatusCode{
		error:      errors.New(message),
		statusCode: http.StatusVariantAlsoNegotiates,
	}
}

// WrapErrVariantAlsoNegotiates returns a new ErrVariantAlsoNegotiates, wrapping an existing error
func WrapErrVariantAlsoNegotiates(err error) error {
	return &ErrorWithStatusCode{
		error:      err,
		statusCode: http.StatusVariantAlsoNegotiates,
	}
}

func GetByStatusCode(statusCode int) func(string) error {
	switch statusCode {

	case http.StatusAccepted:
		return NewErrAccepted

	case http.StatusAlreadyReported:
		return NewErrAlreadyReported

	case http.StatusBadGateway:
		return NewErrBadGateway

	case http.StatusBadRequest:
		return NewErrBadRequest

	case http.StatusConflict:
		return NewErrConflict

	case http.StatusContinue:
		return NewErrContinue

	case http.StatusCreated:
		return NewErrCreated

	case http.StatusEarlyHints:
		return NewErrEarlyHints

	case http.StatusExpectationFailed:
		return NewErrExpectationFailed

	case http.StatusFailedDependency:
		return NewErrFailedDependency

	case http.StatusForbidden:
		return NewErrForbidden

	case http.StatusFound:
		return NewErrFound

	case http.StatusGatewayTimeout:
		return NewErrGatewayTimeout

	case http.StatusGone:
		return NewErrGone

	case http.StatusHTTPVersionNotSupported:
		return NewErrHTTPVersionNotSupported

	case http.StatusIMUsed:
		return NewErrIMUsed

	case http.StatusInsufficientStorage:
		return NewErrInsufficientStorage

	case http.StatusInternalServerError:
		return NewErrInternalServerError

	case http.StatusLengthRequired:
		return NewErrLengthRequired

	case http.StatusLocked:
		return NewErrLocked

	case http.StatusLoopDetected:
		return NewErrLoopDetected

	case http.StatusMethodNotAllowed:
		return NewErrMethodNotAllowed

	case http.StatusMisdirectedRequest:
		return NewErrMisdirectedRequest

	case http.StatusMovedPermanently:
		return NewErrMovedPermanently

	case http.StatusMultiStatus:
		return NewErrMultiStatus

	case http.StatusMultipleChoices:
		return NewErrMultipleChoices

	case http.StatusNetworkAuthenticationRequired:
		return NewErrNetworkAuthenticationRequired

	case http.StatusNoContent:
		return NewErrNoContent

	case http.StatusNonAuthoritativeInfo:
		return NewErrNonAuthoritativeInfo

	case http.StatusNotAcceptable:
		return NewErrNotAcceptable

	case http.StatusNotExtended:
		return NewErrNotExtended

	case http.StatusNotFound:
		return NewErrNotFound

	case http.StatusNotImplemented:
		return NewErrNotImplemented

	case http.StatusNotModified:
		return NewErrNotModified

	case http.StatusPartialContent:
		return NewErrPartialContent

	case http.StatusPaymentRequired:
		return NewErrPaymentRequired

	case http.StatusPermanentRedirect:
		return NewErrPermanentRedirect

	case http.StatusPreconditionFailed:
		return NewErrPreconditionFailed

	case http.StatusPreconditionRequired:
		return NewErrPreconditionRequired

	case http.StatusProcessing:
		return NewErrProcessing

	case http.StatusProxyAuthRequired:
		return NewErrProxyAuthRequired

	case http.StatusRequestEntityTooLarge:
		return NewErrRequestEntityTooLarge

	case http.StatusRequestHeaderFieldsTooLarge:
		return NewErrRequestHeaderFieldsTooLarge

	case http.StatusRequestTimeout:
		return NewErrRequestTimeout

	case http.StatusRequestURITooLong:
		return NewErrRequestURITooLong

	case http.StatusRequestedRangeNotSatisfiable:
		return NewErrRequestedRangeNotSatisfiable

	case http.StatusResetContent:
		return NewErrResetContent

	case http.StatusSeeOther:
		return NewErrSeeOther

	case http.StatusServiceUnavailable:
		return NewErrServiceUnavailable

	case http.StatusSwitchingProtocols:
		return NewErrSwitchingProtocols

	case http.StatusTeapot:
		return NewErrTeapot

	case http.StatusTemporaryRedirect:
		return NewErrTemporaryRedirect

	case http.StatusTooEarly:
		return NewErrTooEarly

	case http.StatusTooManyRequests:
		return NewErrTooManyRequests

	case http.StatusUnauthorized:
		return NewErrUnauthorized

	case http.StatusUnavailableForLegalReasons:
		return NewErrUnavailableForLegalReasons

	case http.StatusUnprocessableEntity:
		return NewErrUnprocessableEntity

	case http.StatusUnsupportedMediaType:
		return NewErrUnsupportedMediaType

	case http.StatusUpgradeRequired:
		return NewErrUpgradeRequired

	case http.StatusUseProxy:
		return NewErrUseProxy

	case http.StatusVariantAlsoNegotiates:
		return NewErrVariantAlsoNegotiates

	}
	return nil
}

func GetWrapByStatusCode(statusCode int) func(error) error {
	switch statusCode {

	case http.StatusAccepted:
		return WrapErrAccepted

	case http.StatusAlreadyReported:
		return WrapErrAlreadyReported

	case http.StatusBadGateway:
		return WrapErrBadGateway

	case http.StatusBadRequest:
		return WrapErrBadRequest

	case http.StatusConflict:
		return WrapErrConflict

	case http.StatusContinue:
		return WrapErrContinue

	case http.StatusCreated:
		return WrapErrCreated

	case http.StatusEarlyHints:
		return WrapErrEarlyHints

	case http.StatusExpectationFailed:
		return WrapErrExpectationFailed

	case http.StatusFailedDependency:
		return WrapErrFailedDependency

	case http.StatusForbidden:
		return WrapErrForbidden

	case http.StatusFound:
		return WrapErrFound

	case http.StatusGatewayTimeout:
		return WrapErrGatewayTimeout

	case http.StatusGone:
		return WrapErrGone

	case http.StatusHTTPVersionNotSupported:
		return WrapErrHTTPVersionNotSupported

	case http.StatusIMUsed:
		return WrapErrIMUsed

	case http.StatusInsufficientStorage:
		return WrapErrInsufficientStorage

	case http.StatusInternalServerError:
		return WrapErrInternalServerError

	case http.StatusLengthRequired:
		return WrapErrLengthRequired

	case http.StatusLocked:
		return WrapErrLocked

	case http.StatusLoopDetected:
		return WrapErrLoopDetected

	case http.StatusMethodNotAllowed:
		return WrapErrMethodNotAllowed

	case http.StatusMisdirectedRequest:
		return WrapErrMisdirectedRequest

	case http.StatusMovedPermanently:
		return WrapErrMovedPermanently

	case http.StatusMultiStatus:
		return WrapErrMultiStatus

	case http.StatusMultipleChoices:
		return WrapErrMultipleChoices

	case http.StatusNetworkAuthenticationRequired:
		return WrapErrNetworkAuthenticationRequired

	case http.StatusNoContent:
		return WrapErrNoContent

	case http.StatusNonAuthoritativeInfo:
		return WrapErrNonAuthoritativeInfo

	case http.StatusNotAcceptable:
		return WrapErrNotAcceptable

	case http.StatusNotExtended:
		return WrapErrNotExtended

	case http.StatusNotFound:
		return WrapErrNotFound

	case http.StatusNotImplemented:
		return WrapErrNotImplemented

	case http.StatusNotModified:
		return WrapErrNotModified

	case http.StatusPartialContent:
		return WrapErrPartialContent

	case http.StatusPaymentRequired:
		return WrapErrPaymentRequired

	case http.StatusPermanentRedirect:
		return WrapErrPermanentRedirect

	case http.StatusPreconditionFailed:
		return WrapErrPreconditionFailed

	case http.StatusPreconditionRequired:
		return WrapErrPreconditionRequired

	case http.StatusProcessing:
		return WrapErrProcessing

	case http.StatusProxyAuthRequired:
		return WrapErrProxyAuthRequired

	case http.StatusRequestEntityTooLarge:
		return WrapErrRequestEntityTooLarge

	case http.StatusRequestHeaderFieldsTooLarge:
		return WrapErrRequestHeaderFieldsTooLarge

	case http.StatusRequestTimeout:
		return WrapErrRequestTimeout

	case http.StatusRequestURITooLong:
		return WrapErrRequestURITooLong

	case http.StatusRequestedRangeNotSatisfiable:
		return WrapErrRequestedRangeNotSatisfiable

	case http.StatusResetContent:
		return WrapErrResetContent

	case http.StatusSeeOther:
		return WrapErrSeeOther

	case http.StatusServiceUnavailable:
		return WrapErrServiceUnavailable

	case http.StatusSwitchingProtocols:
		return WrapErrSwitchingProtocols

	case http.StatusTeapot:
		return WrapErrTeapot

	case http.StatusTemporaryRedirect:
		return WrapErrTemporaryRedirect

	case http.StatusTooEarly:
		return WrapErrTooEarly

	case http.StatusTooManyRequests:
		return WrapErrTooManyRequests

	case http.StatusUnauthorized:
		return WrapErrUnauthorized

	case http.StatusUnavailableForLegalReasons:
		return WrapErrUnavailableForLegalReasons

	case http.StatusUnprocessableEntity:
		return WrapErrUnprocessableEntity

	case http.StatusUnsupportedMediaType:
		return WrapErrUnsupportedMediaType

	case http.StatusUpgradeRequired:
		return WrapErrUpgradeRequired

	case http.StatusUseProxy:
		return WrapErrUseProxy

	case http.StatusVariantAlsoNegotiates:
		return WrapErrVariantAlsoNegotiates

	}
	return nil
}

var defaultMessages = map[int]string{
	http.StatusAccepted:                      "Accepted",
	http.StatusAlreadyReported:               "Already Reported",
	http.StatusBadGateway:                    "Bad Gateway",
	http.StatusBadRequest:                    "Bad Request",
	http.StatusConflict:                      "Conflict",
	http.StatusContinue:                      "Continue",
	http.StatusCreated:                       "Created",
	http.StatusEarlyHints:                    "Early Hints",
	http.StatusExpectationFailed:             "Expectation Failed",
	http.StatusFailedDependency:              "Failed Dependency",
	http.StatusForbidden:                     "Forbidden",
	http.StatusFound:                         "Found",
	http.StatusGatewayTimeout:                "Gateway Timeout",
	http.StatusGone:                          "Gone",
	http.StatusHTTPVersionNotSupported:       "HTTPVersion Not Supported",
	http.StatusIMUsed:                        "IMUsed",
	http.StatusInsufficientStorage:           "Insufficient Storage",
	http.StatusInternalServerError:           "Internal Server Error",
	http.StatusLengthRequired:                "Length Required",
	http.StatusLocked:                        "Locked",
	http.StatusLoopDetected:                  "Loop Detected",
	http.StatusMethodNotAllowed:              "Method Not Allowed",
	http.StatusMisdirectedRequest:            "Misdirected Request",
	http.StatusMovedPermanently:              "Moved Permanently",
	http.StatusMultiStatus:                   "Multi Status",
	http.StatusMultipleChoices:               "Multiple Choices",
	http.StatusNetworkAuthenticationRequired: "Network Authentication Required",
	http.StatusNoContent:                     "No Content",
	http.StatusNonAuthoritativeInfo:          "Non Authoritative Info",
	http.StatusNotAcceptable:                 "Not Acceptable",
	http.StatusNotExtended:                   "Not Extended",
	http.StatusNotFound:                      "Not Found",
	http.StatusNotImplemented:                "Not Implemented",
	http.StatusNotModified:                   "Not Modified",
	http.StatusPartialContent:                "Partial Content",
	http.StatusPaymentRequired:               "Payment Required",
	http.StatusPermanentRedirect:             "Permanent Redirect",
	http.StatusPreconditionFailed:            "Precondition Failed",
	http.StatusPreconditionRequired:          "Precondition Required",
	http.StatusProcessing:                    "Processing",
	http.StatusProxyAuthRequired:             "Proxy Auth Required",
	http.StatusRequestEntityTooLarge:         "Request Entity Too Large",
	http.StatusRequestHeaderFieldsTooLarge:   "Request Header Fields Too Large",
	http.StatusRequestTimeout:                "Request Timeout",
	http.StatusRequestURITooLong:             "Request URIToo Long",
	http.StatusRequestedRangeNotSatisfiable:  "Requested Range Not Satisfiable",
	http.StatusResetContent:                  "Reset Content",
	http.StatusSeeOther:                      "See Other",
	http.StatusServiceUnavailable:            "Service Unavailable",
	http.StatusSwitchingProtocols:            "Switching Protocols",
	http.StatusTeapot:                        "Teapot",
	http.StatusTemporaryRedirect:             "Temporary Redirect",
	http.StatusTooEarly:                      "Too Early",
	http.StatusTooManyRequests:               "Too Many Requests",
	http.StatusUnauthorized:                  "Unauthorized",
	http.StatusUnavailableForLegalReasons:    "Unavailable For Legal Reasons",
	http.StatusUnprocessableEntity:           "Unprocessable Entity",
	http.StatusUnsupportedMediaType:          "Unsupported Media Type",
	http.StatusUpgradeRequired:               "Upgrade Required",
	http.StatusUseProxy:                      "Use Proxy",
	http.StatusVariantAlsoNegotiates:         "Variant Also Negotiates",
}