@opra/common
Version:
Opra common package
301 lines (300 loc) • 16.2 kB
JavaScript
"use strict";
// noinspection JSUnusedGlobalSymbols
Object.defineProperty(exports, "__esModule", { value: true });
exports.HttpStatusCode = void 0;
/**
* https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#successful_responses
*/
var HttpStatusCode;
(function (HttpStatusCode) {
/* *** Information responses *** */
/**
* This interim response indicates that the client should continue the request or
* ignore the response if the request is already finished.
*/
HttpStatusCode[HttpStatusCode["CONTINUE"] = 100] = "CONTINUE";
/**
* This code is sent in response to an Upgrade request header from the client and
* indicates the protocol the server is switching to.
*/
HttpStatusCode[HttpStatusCode["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
/**
* This code indicates that the server has received and is processing the request, but no response is available yet.
*/
HttpStatusCode[HttpStatusCode["PROCESSING"] = 102] = "PROCESSING";
/**
* This status code is primarily intended to be used with the Link header, letting the user agent
* start preloading resources while the server prepares a response.
*/
HttpStatusCode[HttpStatusCode["EARLYHINTS"] = 103] = "EARLYHINTS";
/* *** Successful responses *** */
/**
* The request succeeded.
*/
HttpStatusCode[HttpStatusCode["OK"] = 200] = "OK";
/**
* The request succeeded, and a new resource was created as a result.
* This is typically the response sent after POST requests, or some PUT requests.
*/
HttpStatusCode[HttpStatusCode["CREATED"] = 201] = "CREATED";
/**
* The request has been received but not yet acted upon. It is noncommittal,
* since there is no way in HTTP to later send an asynchronous response indicating
* the outcome of the request. It is intended for cases where another process or
* server handles the request, or for batch processing.
*/
HttpStatusCode[HttpStatusCode["ACCEPTED"] = 202] = "ACCEPTED";
/**
* This response code means the returned metadata is not exactly the same as is available from
* the origin server, but is collected from a local or a third-party copy. This is mostly used
* for mirrors or backups of another resource. Except for that specific case, the 200 OK
* response is preferred to this status.
*/
HttpStatusCode[HttpStatusCode["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
/**
* There is no content to send for this request, but the headers may be useful.
* The user agent may update its cached headers for this resource with the new ones.
*/
HttpStatusCode[HttpStatusCode["NO_CONTENT"] = 204] = "NO_CONTENT";
/**
* Tells the user agent to reset the document which sent this request.
*/
HttpStatusCode[HttpStatusCode["RESET_CONTENT"] = 205] = "RESET_CONTENT";
/**
* This response code is used when the Range header is sent from the client to request only part of a resource.
*/
HttpStatusCode[HttpStatusCode["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
/* *** Redirection messages *** */
/**
* The request has more than one possible response. The user agent or user should choose one of them.
* (There is no standardized way of choosing one of the responses, but HTML links to the possibilities
* are recommended so the user can pick.)
*/
HttpStatusCode[HttpStatusCode["AMBIGUOUS"] = 300] = "AMBIGUOUS";
/**
* The URL of the requested resource has been changed permanently. The new URL is given in the response.
*/
HttpStatusCode[HttpStatusCode["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
/**
* This response code means that the URI of requested resource has been changed temporarily.
* Further changes in the URI might be made in the future. Therefore, this same URI should
* be used by the client in future requests.
*/
HttpStatusCode[HttpStatusCode["FOUND"] = 302] = "FOUND";
/**
* This is used for caching purposes. It tells the client that the response has not been modified,
* so the client can continue to use the same cached version of the response.
*/
HttpStatusCode[HttpStatusCode["SEE_OTHER"] = 303] = "SEE_OTHER";
/**
*
*/
HttpStatusCode[HttpStatusCode["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
/**
* The server sends this response to direct the client to get the requested resource at another
* URI with same method that was used in the prior request. This has the same semantics as
* the 302 Found HTTP response code, with the exception that the user agent must not change
* the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.
*/
HttpStatusCode[HttpStatusCode["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
/**
* This means that the resource is now permanently located at another URI, specified by the Location:
* HTTP Response header. This has the same semantics as the 301 Moved Permanently HTTP response code,
* with the exception that the user agent must not change the HTTP method used: if a POST was used
* in the first request, a POST must be used in the second request.
*/
HttpStatusCode[HttpStatusCode["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
/* *** Client error responses *** */
/**
* The server cannot or will not process the request due to something that is perceived to be a client error
* (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
*/
HttpStatusCode[HttpStatusCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
/**
* Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated".
* That is, the client must authenticate itself to get the requested response.
*/
HttpStatusCode[HttpStatusCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
/**
* This response code is reserved for future use. The initial aim for creating this code was using
* it for digital payment systems, however this status code is used very rarely and no standard convention exists.
*/
HttpStatusCode[HttpStatusCode["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
/**
* The client does not have access rights to the content; that is, it is unauthorized,
* so the server is refusing to give the requested resource. Unlike 401 Unauthorized,
* the client's identity is known to the server.
*/
HttpStatusCode[HttpStatusCode["FORBIDDEN"] = 403] = "FORBIDDEN";
/**
* The server can not find the requested resource. In the browser, this means the URL is not recognized.
* In an API, this can also mean that the endpoint is valid but the resource itself does not exist.
* Servers may also send this response instead of 403 Forbidden to hide the existence of a resource
* from an unauthorized client. This response code is probably the most well known due to its
* frequent occurrence on the web.
*/
HttpStatusCode[HttpStatusCode["NOT_FOUND"] = 404] = "NOT_FOUND";
/**
* The request method is known by the server but is not supported by the target resource.
* For example, an API may not allow calling DELETE to remove a resource.
*/
HttpStatusCode[HttpStatusCode["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
/**
* This response is sent when the web server, after performing server-driven content negotiation,
* doesn't find any content that conforms to the criteria given by the user agent.
*/
HttpStatusCode[HttpStatusCode["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
/**
* This is similar to 401 Unauthorized but authentication is needed to be done by a proxy.
*/
HttpStatusCode[HttpStatusCode["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
/**
* This response is sent on an idle connection by some servers, even without any previous request by the client.
* It means that the server would like to shut down this unused connection.
* This response is used much more since some browsers,
* like Chrome, Firefox 27+, or IE9, use HTTP pre-connection mechanisms to speed up surfing.
* Also note that some servers merely shut down the connection without sending this message.
*/
HttpStatusCode[HttpStatusCode["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
/**
* This response is sent when a request conflicts with the current state of the server.
*/
HttpStatusCode[HttpStatusCode["CONFLICT"] = 409] = "CONFLICT";
/**
* This response is sent when the requested content has been permanently deleted from server,
* with no forwarding address. Clients are expected to remove their caches and links to the resource.
* The HTTP specification intends this status code to be used for "limited-time, promotional services".
* APIs should not feel compelled to indicate resources that have been deleted with this status code.
*/
HttpStatusCode[HttpStatusCode["GONE"] = 410] = "GONE";
/**
* Server rejected the request because the Content-Length header field is not defined and the server requires it.
*/
HttpStatusCode[HttpStatusCode["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
/**
* The client has indicated preconditions in its headers which the server does not meet.
*/
HttpStatusCode[HttpStatusCode["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
/**
* Request entity is larger than limits defined by server. The server might close the connection or
* return an Retry-After header field.
*/
HttpStatusCode[HttpStatusCode["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
/**
* The URI requested by the client is longer than the server is willing to interpret.
*/
HttpStatusCode[HttpStatusCode["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
/**
* The media format of the requested data is not supported by the server, so the server is rejecting the request.
*/
HttpStatusCode[HttpStatusCode["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
/**
* The range specified by the Range header field in the request cannot be fulfilled.
* It's possible that the range is outside the size of the target URI's data.
*/
HttpStatusCode[HttpStatusCode["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
/**
* This response code means the expectation indicated by the Expect request header field cannot be met by the server.
*/
HttpStatusCode[HttpStatusCode["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
/**
* The server refuses the attempt to brew coffee with a teapot.
*/
HttpStatusCode[HttpStatusCode["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
/**
* The request was directed at a server that is not able to produce a response.
* This can be sent by a server that is not configured to produce responses for
* the combination of scheme and authority that are included in the request URI.
*/
HttpStatusCode[HttpStatusCode["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
/**
* The request was well-formed but was unable to be followed due to semantic errors.
*/
HttpStatusCode[HttpStatusCode["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
/**
* The resource that is being accessed is locked.
*/
HttpStatusCode[HttpStatusCode["LOCKED"] = 423] = "LOCKED";
/**
* The request failed due to failure of a previous request.
*/
HttpStatusCode[HttpStatusCode["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
/**
* Indicates that the server is unwilling to risk processing a request that might be replayed.
*/
HttpStatusCode[HttpStatusCode["TOO_EARLY"] = 425] = "TOO_EARLY";
/**
* The server refuses to perform the request using the current protocol but might be willing
* to do so after the client upgrades to a different protocol. The server sends an Upgrade
* header in a 426 response to indicate the required protocol(s).
*/
HttpStatusCode[HttpStatusCode["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
/**
* The origin server requires the request to be conditional. This response is intended to prevent
* the 'lost update' problem, where a client GETs a resource's state, modifies it and PUTs
* it back to the server, when meanwhile a third party has modified the state on the server,
* leading to a conflict.
*/
HttpStatusCode[HttpStatusCode["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
/**
* The user has sent too many requests in a given amount of time ("rate limiting").
*/
HttpStatusCode[HttpStatusCode["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
/* *** Server error responses *** */
/**
* The server has encountered a situation it does not know how to handle.
*/
HttpStatusCode[HttpStatusCode["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
/**
* The request method is not supported by the server and cannot be handled.
* The only methods that servers are required to support (and therefore that must not return this code)
* are GET and HEAD.
*/
HttpStatusCode[HttpStatusCode["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
/**
* This error response means that the server, while working as a gateway to get
* a response needed to handle the request, got an invalid response.
*/
HttpStatusCode[HttpStatusCode["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
/**
* The server is not ready to handle the request. Common causes are a server that is down for maintenance
* or that is overloaded. Note that together with this response, a user-friendly page explaining
* the problem should be sent. This response should be used for temporary conditions and the
* Retry-After HTTP header should, if possible, contain the estimated time before the
* recovery of the service. The webmaster must also take care about the caching-related
* headers that are sent along with this response, as these temporary condition responses
* should usually not be cached.
*/
HttpStatusCode[HttpStatusCode["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
/**
* This error response is given when the server is acting as a gateway and cannot get a response in time.
*/
HttpStatusCode[HttpStatusCode["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
/**
* The HTTP version used in the request is not supported by the server.
*/
HttpStatusCode[HttpStatusCode["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
/**
* The server has an internal configuration error: the chosen variant resource is configured
* to engage in transparent content negotiation itself, and is therefore not a proper end
* point in the negotiation process.
*/
HttpStatusCode[HttpStatusCode["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
/**
* The method could not be performed on the resource because the server is unable to store
* the representation needed to successfully complete the request.
*/
HttpStatusCode[HttpStatusCode["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
/**
* The server detected an infinite loop while processing the request.
*/
HttpStatusCode[HttpStatusCode["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
/**
* Further extensions to the request are required for the server to fulfill it.
*/
HttpStatusCode[HttpStatusCode["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
/**
* Indicates that the client needs to authenticate to gain network access.
*/
HttpStatusCode[HttpStatusCode["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
})(HttpStatusCode || (exports.HttpStatusCode = HttpStatusCode = {}));