cliex

var (
	// ErrCBOpenState is returned when the CB state is open
	ErrCBOpenState = gobreaker.ErrOpenState
	// ErrTooManyRequests is returned when the CB state is half open and the requests count is over the cb maxRequests
	ErrCBTooManyRequests = gobreaker.ErrTooManyRequests
)

var (
	// ErrBadRequest is when the server cannot or will not process the request due to a client error
	// (e.g., malformed request syntax, size too large, invalid request message framing, or deceptive request routing).
	ErrBadRequest = errors.New("code 400, bad request")

	// ErrUnauthorized is used when authentication is required and has failed or has not yet been provided.
	// The response must include a WWW-Authenticate header field containing a challenge applicable to the requested resource.
	ErrUnauthorized = errors.New("code 401, unauthorized")

	// ErrPaymentRequired is reserved for future use. This code might indicate a digital cash or micropayment requirement.
	ErrPaymentRequired = errors.New("code 402, payment required")

	// ErrForbidden indicates that the server refuses to authorize the request, even though the server understands it.
	// This could be because the user does not have permissions for a resource, or because of another form of prohibition.
	ErrForbidden = errors.New("code 403, forbidden")

	// ErrNotFound indicates that the server can't find the requested resource. Further requests are allowable.
	ErrNotFound = errors.New("code 404, not found")

	// ErrMethodNotAllowed is when a request method is not supported for the requested resource.
	// For example, a GET request on a form designed only to be POSTed.
	ErrMethodNotAllowed = errors.New("code 405, method not allowed")

	// ErrNotAcceptable indicates that the resource is only capable of generating content not acceptable by the Accept headers.
	ErrNotAcceptable = errors.New("code 406, not acceptable")

	// ErrProxyAuthRequired suggests that the client must first authenticate itself with the proxy.
	ErrProxyAuthRequired = errors.New("code 407, proxy authentication required")

	// ErrRequestTimeout means the server timed out waiting for the request.
	// "The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time."
	ErrRequestTimeout = errors.New("code 408, request timeout")

	// ErrConflict indicates the request could not be processed due to a conflict in the current state of the resource, such as a simultaneous edit conflict.
	ErrConflict = errors.New("code 409, conflict")

	// ErrGone signals that the resource requested is no longer available and will not be available again.
	// The client should not request the resource in the future.
	ErrGone = errors.New("code 410, gone")

	// ErrLengthRequired indicates that the request did not specify the length of its content, which is required.
	ErrLengthRequired = errors.New("code 411, length required")

	// ErrPreconditionFailed demonstrates the server does not meet one of the preconditions given in the request headers.
	ErrPreconditionFailed = errors.New("code 412, precondition failed")

	// ErrPayloadTooLarge denotes that the request is larger than the server is willing or able to process.
	ErrPayloadTooLarge = errors.New("code 413, payload too large")

	// ErrURITooLong means the URI provided was too long for the server to process.
	ErrURITooLong = errors.New("code 414, URI too long")

	// ErrUnsupportedMediaType is when the request entity has a media type which the server or resource does not support.
	ErrUnsupportedMediaType = errors.New("code 415, unsupported media type")

	// ErrRangeNotSatisfiable indicates the client has asked for a portion of the file, but the server cannot supply that portion.
	ErrRangeNotSatisfiable = errors.New("code 416, range not satisfiable")

	// ErrExpectationFailed implies the server cannot meet the requirements of the Expect request-header field.
	ErrExpectationFailed = errors.New("code 417, expectation failed")

	// ErrTeapot is an Easter egg response code indicating the server is a teapot, not capable of brewing coffee.
	ErrTeapot = errors.New("code 418, I'm a teapot")

	// ErrMisdirectedRequest indicates the request was directed at a server that is not able to produce a response.
	ErrMisdirectedRequest = errors.New("code 421, misdirected request")

	// ErrUnprocessableEntity means the request was well-formed but could not be processed by the server.
	ErrUnprocessableEntity = errors.New("code 422, unprocessable entity")

	// ErrLocked suggests the resource that is being accessed is locked.
	ErrLocked = errors.New("code 423, locked")

	// ErrFailedDependency indicates the request failed because it depended on another request and that request failed.
	ErrFailedDependency = errors.New("code 424, failed dependency")

	// ErrTooEarly indicates the server is unwilling to process a request that might be replayed.
	ErrTooEarly = errors.New("code 425, too early")

	// ErrUpgradeRequired indicates the client should switch to a different protocol, as suggested in the Upgrade header.
	ErrUpgradeRequired = errors.New("code 426, upgrade required")

	// ErrPreconditionRequired is used when the server requires that the request is conditional.
	// This is to prevent 'lost update' problems when a client GETs a resource's state, modifies it, and PUTs it back to the server.
	ErrPreconditionRequired = errors.New("code 428, precondition required")

	// ErrTooManyRequests indicates the user has sent too many requests in a given time frame, usually indicative of a rate-limiting policy.
	ErrTooManyRequests = errors.New("code 429, too many requests")

	// ErrHeaderFieldsTooLarge suggests that either an individual header field, or all the header fields collectively, are too large.
	ErrHeaderFieldsTooLarge = errors.New("code 431, request header fields too large")

	// ErrUnavailableForLegalReasons indicates the requested resource is unavailable due to legal reasons.
	ErrUnavailableForLegalReasons = errors.New("code 451, unavailable for legal reasons")
)

var (
	// ErrInternalServerError represents the HTTP 500 error.
	// It is a generic error message, given when an unexpected condition was encountered
	// and no more specific message is suitable.
	ErrInternalServerError = errors.New("code 500, internal server error")

	// ErrNotImplemented represents the HTTP 501 error.
	// The server either does not recognize the request method, or it lacks the ability to fulfill the request.
	// Usually, this implies future availability, such as a new feature of a web-service API.
	ErrNotImplemented = errors.New("code 501, not implemented")

	// ErrBadGateway represents the HTTP 502 error.
	// The server was acting as a gateway or proxy and received an invalid response from the upstream server.
	ErrBadGateway = errors.New("code 502, bad gateway")

	// ErrServiceUnavailable represents the HTTP 503 error.
	// The server is currently unable to handle the request due to a temporary overloading or maintenance of the server.
	ErrServiceUnavailable = errors.New("code 503, service unavailable")

	// ErrGatewayTimeout represents the HTTP 504 error.
	// The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
	ErrGatewayTimeout = errors.New("code 504, gateway timeout")

	// ErrHTTPVersionNotSupported represents the HTTP 505 error.
	// The server does not support, or refuses to support, the HTTP protocol version that was used in the request message.
	ErrHTTPVersionNotSupported = errors.New("code 505, HTTP version not supported")

	// ErrVariantAlsoNegotiates represents the HTTP 506 error.
	// Transparent content negotiation for the request results in a circular reference.
	ErrVariantAlsoNegotiates = errors.New("code 506, variant also negotiates")

	// ErrInsufficientStorage represents the HTTP 507 error.
	// The server is unable to store the representation needed to complete the request.
	ErrInsufficientStorage = errors.New("code 507, insufficient storage")

	// ErrLoopDetected represents the HTTP 508 error.
	// The server detected an infinite loop while processing the request.
	ErrLoopDetected = errors.New("code 508, loop detected")

	// ErrNotExtended represents the HTTP 510 error.
	// Further extensions to the request are required for the server to fulfill it.
	ErrNotExtended = errors.New("code 510, not extended")

	// ErrNetworkAuthenticationRequired represents the HTTP 511 error.
	// The client needs to authenticate to gain network access, often used by intercepting
	// proxies used to control access to the network, e.g., for "captive portal" purposes.
	ErrNetworkAuthenticationRequired = errors.New("code 511, network authentication required")
)

var (

	// ErrPageExpired is used by the Laravel Framework when a CSRF Token is missing or expired.
	ErrPageExpired = errors.New("code 419, page expired")

	// ErrMethodFailure is used by the Spring Framework when a method has failed.
	ErrMethodFailure = errors.New("code 420, method failure")

	// ErrEnhanceYourCalm used by Twitter's API to signal that the client is being rate-limited.
	ErrEnhanceYourCalm = errors.New("code 420, enhance your calm")

	// ErrRequestHeaderFieldsTooLarge was used by Shopify when too many URLs were requested in a timeframe.
	ErrRequestHeaderFieldsTooLarge = errors.New("code 430, request headers fields too large")

	// ErrShopifySecurityRejection is returned by Shopify if the request was deemed malicious.
	ErrShopifySecurityRejection = errors.New("code 430, security rejection")

	// ErrBlockedByWindowsParentalControls signifies being blocked by Microsoft parental controls.
	ErrBlockedByWindowsParentalControls = errors.New("code 450, blocked by Windows Parental Controls")

	// ErrInvalidToken indicates an expired or otherwise invalid token in ArcGIS.
	ErrInvalidToken = errors.New("code 498, invalid token")

	// ErrTokenRequired indicates that a token is required but was not submitted in ArcGIS.
	ErrTokenRequired = errors.New("code 499, token required")

	// ErrBandwidthLimitExceeded indicates that the server's bandwidth limit has been exceeded.
	ErrBandwidthLimitExceeded = errors.New("code 509, bandwidth limit exceeded")

	// ErrSiteIsOverloaded is used by Qualys when the site cannot process the request due to overload.
	ErrSiteIsOverloaded = errors.New("code 529, site is overloaded")

	// ErrSiteIsFrozen indicates a site that has been frozen due to inactivity.
	ErrSiteIsFrozen = errors.New("code 530, site is frozen")

	// ErrOriginDNSError is used by Shopify to indicate that Cloudflare can't resolve the requested DNS record.
	ErrOriginDNSError = errors.New("code 530, origin DNS error")

	// ErrTemporarilyDisabled is returned by Shopify when an endpoint has been temporarily disabled.
	ErrTemporarilyDisabled = errors.New("code 540, temporarily disabled")

	// ErrNetworkReadTimeoutError is an informal convention used by proxies to indicate a read timeout.
	ErrNetworkReadTimeoutError = errors.New("code 598, network read timeout error")

	// ErrNetworkConnectTimeoutError indicates a network connect timeout.
	ErrNetworkConnectTimeoutError = errors.New("code 599, network connect timeout error")

	// ErrUnexpectedToken is used by Shopify to indicate a JSON syntax error.
	ErrUnexpectedToken = errors.New("code 783, unexpected token")

	// ErrNonStandard is a placeholder for LinkedIn's restriction message.
	ErrNonStandard = errors.New("code 999, non-standard or restricted access error")

	// ErrLoginTimeout is when the client's session has expired and must log in again.
	ErrLoginTimeout = errors.New("code 440, login timeout")

	// ErrRetryWith may be returned to ask for additional information from the client.
	ErrRetryWith = errors.New("code 449, retry with")

	// ErrRedirect in Exchange ActiveSync contexts for mailbox access or server availability.
	ErrRedirect = errors.New("code 451, redirect for efficient server")

	// ErrNoResponse indicates no information returned, with the connection closed immediately.
	ErrNoResponse = errors.New("code 444, no response")

	// ErrRequestHeaderTooLarge signals an excessively large request or header line.
	ErrRequestHeaderTooLarge = errors.New("code 494, request header too large")

	// ErrSSLCertificateError indicates a problem with an SSL certificate provided by the client.
	ErrSSLCertificateError = errors.New("code 495, SSL Certificate Error")

	// ErrSSLCertificateRequired indicates a missing client SSL certificate where required.
	ErrSSLCertificateRequired = errors.New("code 496, SSL Certificate Required")

	// ErrHTTPtoHTTPS denotes a bad request on a wrong port.
	ErrHTTPtoHTTPS = errors.New("code 497, HTTP request sent to HTTPS port")

	// ErrClientClosedRequest arises when a client closes a request before a server responds.
	ErrClientClosedRequest = errors.New("code 499, client closed request")

	// ErrWebServerReturnedUnknownError is an empty or unexpected response error by Cloudflare.
	ErrWebServerReturnedUnknownError = errors.New("code 520, web server returned an unknown error")

	// ErrWebServerIsDown is when a server refuses connections from Cloudflare.
	ErrWebServerIsDown = errors.New("code 521, web server is down")

	// ErrConnectionTimedOut as per contact issues between Cloudflare and the origin server.
	ErrConnectionTimedOut = errors.New("code 522, connection timed out")

	// ErrOriginIsUnreachable indicates DNS or network errors preventing access to the origin server.
	ErrOriginIsUnreachable = errors.New("code 523, origin is unreachable")

	// ErrTimeoutOccurred reflects a failure to receive timely HTTP response despite a TCP connection.
	ErrTimeoutOccurred = errors.New("code 524, a timeout occurred")

	// ErrSSLHandshakeFailed is a failed SSL/TLS handshake negotiation.
	ErrSSLHandshakeFailed = errors.New("code 525, SSL handshake failed")

	// ErrInvalidSSLCertificate indicates issues with validating the SSL certificate on the origin server.
	ErrInvalidSSLCertificate = errors.New("code 526, invalid SSL certificate")

	// ErrRailgunError was related to interrupted Railgun connections, now deprecated.
	ErrRailgunError = errors.New("deprecated code 527, Railgun error")

	// ErrClientClosedConnection signifies early termination by a client.
	ErrClientClosedConnection = errors.New("code 460, client closed the connection")

	// ErrTooManyXForwardedFor is when too many IPs are listed in the X-Forwarded-For header.
	ErrTooManyXForwardedFor = errors.New("code 463, too many X-Forwarded-For headers")

	// ErrIncompatibleProtocolVersions flags a protocol version mismatch.
	ErrIncompatibleProtocolVersions = errors.New("code 464, incompatible protocol versions")

	// ErrUnauthorized relates to authentication errors in load-balanced services.
	ErrUnauthorizedElastic = errors.New("code 561, unauthorized access")
)

var ErrorMapping = map[int]error{
	400: ErrBadRequest,
	401: ErrUnauthorized,
	402: ErrPaymentRequired,
	403: ErrForbidden,
	404: ErrNotFound,
	405: ErrMethodNotAllowed,
	406: ErrNotAcceptable,
	407: ErrProxyAuthRequired,
	408: ErrRequestTimeout,
	409: ErrConflict,
	410: ErrGone,
	411: ErrLengthRequired,
	412: ErrPreconditionFailed,
	413: ErrPayloadTooLarge,
	414: ErrURITooLong,
	415: ErrUnsupportedMediaType,
	416: ErrRangeNotSatisfiable,
	417: ErrExpectationFailed,
	418: ErrTeapot,
	421: ErrMisdirectedRequest,
	422: ErrUnprocessableEntity,
	423: ErrLocked,
	424: ErrFailedDependency,
	425: ErrTooEarly,
	426: ErrUpgradeRequired,
	428: ErrPreconditionRequired,
	429: ErrTooManyRequests,
	431: ErrHeaderFieldsTooLarge,
	451: ErrUnavailableForLegalReasons,

	500: ErrInternalServerError,
	501: ErrNotImplemented,
	502: ErrBadGateway,
	503: ErrServiceUnavailable,
	504: ErrGatewayTimeout,
	505: ErrHTTPVersionNotSupported,
	506: ErrVariantAlsoNegotiates,
	507: ErrInsufficientStorage,
	508: ErrLoopDetected,
	510: ErrNotExtended,
	511: ErrNetworkAuthenticationRequired,

	419: ErrPageExpired,
	420: ErrMethodFailure,
	430: ErrRequestHeaderFieldsTooLarge,
	450: ErrBlockedByWindowsParentalControls,
	498: ErrInvalidToken,
	499: ErrTokenRequired,
	509: ErrBandwidthLimitExceeded,
	529: ErrSiteIsOverloaded,
	530: ErrSiteIsFrozen,
	540: ErrTemporarilyDisabled,
	598: ErrNetworkReadTimeoutError,
	599: ErrNetworkConnectTimeoutError,
	783: ErrUnexpectedToken,
	999: ErrNonStandard,
	440: ErrLoginTimeout,
	449: ErrRetryWith,
	444: ErrNoResponse,
	494: ErrRequestHeaderTooLarge,
	495: ErrSSLCertificateError,
	496: ErrSSLCertificateRequired,
	497: ErrHTTPtoHTTPS,
	520: ErrWebServerReturnedUnknownError,
	521: ErrWebServerIsDown,
	522: ErrConnectionTimedOut,
	523: ErrOriginIsUnreachable,
	524: ErrTimeoutOccurred,
	525: ErrSSLHandshakeFailed,
	526: ErrInvalidSSLCertificate,
	527: ErrRailgunError,
	460: ErrClientClosedConnection,
	463: ErrTooManyXForwardedFor,
	464: ErrIncompatibleProtocolVersions,
	561: ErrUnauthorizedElastic,
}

var HTTPAddressRegexp = regexp.MustCompile(`^https?:\/\/(www\.)?([-a-zA-Z0-9@:%._\+~#=]{1,256}(\.|:)[a-zA-Z0-9()]{1,5}|:[0-9]{2,5})(/[-a-zA-Z0-9()@:%_\+.~#?&//=]*)*$`)