@augment-vir/core 30.0.0

package/dist/augments/http/http-status.js

@@ -0,0 +1,564 @@
+/**
+ * All standardized HTTP status codes.
+ *
+ * These values are automatically parsed from https://developer.mozilla.org/docs/Web/HTTP/Status via
+ * https://github.com/electrovir/augment-vir/blob/dev/packages/scripts/src/scripts/generate-http-status.script.ts
+ */
+export var HttpStatus;
+(function (HttpStatus) {
+    /** 100 level codes (information) */
+    /**
+     * This interim response indicates that the client should continue the request or ignore the
+     * response if the request is already finished.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/100
+     */
+    HttpStatus[HttpStatus["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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/101
+     */
+    HttpStatus[HttpStatus["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    /**
+     * This code indicates that the server has received and is processing the request, but no
+     * response is available yet.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/102
+     */
+    HttpStatus[HttpStatus["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 or preconnect to an
+     * origin from which the page will need resources.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/103
+     */
+    HttpStatus[HttpStatus["EarlyHints"] = 103] = "EarlyHints";
+    /** 200 level codes (success) */
+    /**
+     * The request succeeded. The result meaning of "success" depends on the HTTP method:
+     *
+     * - GET: The resource has been fetched and transmitted in the message body.
+     * - HEAD: The representation headers are included in the response without any message body.
+     * - PUT or POST: The resource describing the result of the action is transmitted in the message
+     *   body.
+     * - TRACE: The message body contains the request message as received by the server.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/200
+     */
+    HttpStatus[HttpStatus["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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/201
+     */
+    HttpStatus[HttpStatus["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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/202
+     */
+    HttpStatus[HttpStatus["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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/203
+     */
+    HttpStatus[HttpStatus["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/204
+     */
+    HttpStatus[HttpStatus["NoContent"] = 204] = "NoContent";
+    /**
+     * Tells the user agent to reset the document which sent this request.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/205
+     */
+    HttpStatus[HttpStatus["ResetContent"] = 205] = "ResetContent";
+    /**
+     * This response code is used when the Range header is sent from the client to request only part
+     * of a resource.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/206
+     */
+    HttpStatus[HttpStatus["PartialContent"] = 206] = "PartialContent";
+    /**
+     * Conveys information about multiple resources, for situations where multiple status codes
+     * might be appropriate.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/207
+     */
+    HttpStatus[HttpStatus["MultiStatus"] = 207] = "MultiStatus";
+    /**
+     * Used inside a [dav:propstat](dav:propstat) response element to avoid repeatedly enumerating
+     * the internal members of multiple bindings to the same collection.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/208
+     */
+    HttpStatus[HttpStatus["AlreadyReported"] = 208] = "AlreadyReported";
+    /**
+     * The server has fulfilled a GET request for the resource, and the response is a representation
+     * of the result of one or more instance-manipulations applied to the current instance.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/226
+     */
+    HttpStatus[HttpStatus["ImUsed"] = 226] = "ImUsed";
+    /** 300 level codes (redirect) */
+    /**
+     * 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.)
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/300
+     */
+    HttpStatus[HttpStatus["MultipleChoices"] = 300] = "MultipleChoices";
+    /**
+     * The URL of the requested resource has been changed permanently. The new URL is given in the
+     * response.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/301
+     */
+    HttpStatus[HttpStatus["MovedPermanently"] = 301] = "MovedPermanently";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/302
+     */
+    HttpStatus[HttpStatus["Found"] = 302] = "Found";
+    /**
+     * The server sent this response to direct the client to get the requested resource at another
+     * URI with a GET request.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/303
+     */
+    HttpStatus[HttpStatus["SeeOther"] = 303] = "SeeOther";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/304
+     */
+    HttpStatus[HttpStatus["NotModified"] = 304] = "NotModified";
+    /**
+     * Defined in a previous version of the HTTP specification to indicate that a requested response
+     * must be accessed by a proxy. It has been deprecated due to security concerns regarding
+     * in-band configuration of a proxy.
+     *
+     * See https://developer.mozilla.org/about:blank#305_use_proxy
+     */
+    HttpStatus[HttpStatus["UseProxy"] = 305] = "UseProxy";
+    /**
+     * This response code is no longer used; it is just reserved. It was used in a previous version
+     * of the HTTP/1.1 specification.
+     *
+     * See https://developer.mozilla.org/about:blank#306_unused
+     */
+    HttpStatus[HttpStatus["Unused"] = 306] = "Unused";
+    /**
+     * The server sends this response to direct the client to get the requested resource at another
+     * URI with the 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/307
+     */
+    HttpStatus[HttpStatus["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/308
+     */
+    HttpStatus[HttpStatus["PermanentRedirect"] = 308] = "PermanentRedirect";
+    /** 400 level codes (clientError) */
+    /**
+     * 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).
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/400
+     */
+    HttpStatus[HttpStatus["BadRequest"] = 400] = "BadRequest";
+    /**
+     * Although the HTTP standard specifies "unauthorized", semantically this response means
+     * "unauthenticated". That is, the client must authenticate itself to get the requested
+     * response.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/401
+     */
+    HttpStatus[HttpStatus["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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/402
+     */
+    HttpStatus[HttpStatus["PaymentRequired"] = 402] = "PaymentRequired";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/403
+     */
+    HttpStatus[HttpStatus["Forbidden"] = 403] = "Forbidden";
+    /**
+     * The server cannot 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/404
+     */
+    HttpStatus[HttpStatus["NotFound"] = 404] = "NotFound";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/405
+     */
+    HttpStatus[HttpStatus["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/406
+     */
+    HttpStatus[HttpStatus["NotAcceptable"] = 406] = "NotAcceptable";
+    /**
+     * This is similar to 401 Unauthorized but authentication is needed to be done by a proxy.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/407
+     */
+    HttpStatus[HttpStatus["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/408
+     */
+    HttpStatus[HttpStatus["RequestTimeout"] = 408] = "RequestTimeout";
+    /**
+     * This response is sent when a request conflicts with the current state of the server.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/409
+     */
+    HttpStatus[HttpStatus["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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/410
+     */
+    HttpStatus[HttpStatus["Gone"] = 410] = "Gone";
+    /**
+     * Server rejected the request because the Content-Length header field is not defined and the
+     * server requires it.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/411
+     */
+    HttpStatus[HttpStatus["LengthRequired"] = 411] = "LengthRequired";
+    /**
+     * The client has indicated preconditions in its headers which the server does not meet.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/412
+     */
+    HttpStatus[HttpStatus["PreconditionFailed"] = 412] = "PreconditionFailed";
+    /**
+     * Request entity is larger than limits defined by server. The server might close the connection
+     * or return an Retry-After header field.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/413
+     */
+    HttpStatus[HttpStatus["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    /**
+     * The URI requested by the client is longer than the server is willing to interpret.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/414
+     */
+    HttpStatus[HttpStatus["UriTooLong"] = 414] = "UriTooLong";
+    /**
+     * The media format of the requested data is not supported by the server, so the server is
+     * rejecting the request.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/415
+     */
+    HttpStatus[HttpStatus["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/416
+     */
+    HttpStatus[HttpStatus["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    /**
+     * This response code means the expectation indicated by the Expect request header field cannot
+     * be met by the server.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/417
+     */
+    HttpStatus[HttpStatus["ExpectationFailed"] = 417] = "ExpectationFailed";
+    /**
+     * The server refuses the attempt to brew coffee with a teapot.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/418
+     */
+    HttpStatus[HttpStatus["ImATeapot"] = 418] = "ImATeapot";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/421
+     */
+    HttpStatus[HttpStatus["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    /**
+     * The request was well-formed but was unable to be followed due to semantic errors.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/422
+     */
+    HttpStatus[HttpStatus["UnprocessableContent"] = 422] = "UnprocessableContent";
+    /**
+     * The resource that is being accessed is locked.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/423
+     */
+    HttpStatus[HttpStatus["Locked"] = 423] = "Locked";
+    /**
+     * The request failed due to failure of a previous request.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/424
+     */
+    HttpStatus[HttpStatus["FailedDependency"] = 424] = "FailedDependency";
+    /**
+     * Indicates that the server is unwilling to risk processing a request that might be replayed.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/425
+     */
+    HttpStatus[HttpStatus["TooEarly"] = 425] = "TooEarly";
+    /**
+     * 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).
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/426
+     */
+    HttpStatus[HttpStatus["UpgradeRequired"] = 426] = "UpgradeRequired";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/428
+     */
+    HttpStatus[HttpStatus["PreconditionRequired"] = 428] = "PreconditionRequired";
+    /**
+     * The user has sent too many requests in a given amount of time ("rate limiting").
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/429
+     */
+    HttpStatus[HttpStatus["TooManyRequests"] = 429] = "TooManyRequests";
+    /**
+     * The server is unwilling to process the request because its header fields are too large. The
+     * request may be resubmitted after reducing the size of the request header fields.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/431
+     */
+    HttpStatus[HttpStatus["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    /**
+     * The user agent requested a resource that cannot legally be provided, such as a web page
+     * censored by a government.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/451
+     */
+    HttpStatus[HttpStatus["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    /** 500 level codes (serverError) */
+    /**
+     * The server has encountered a situation it does not know how to handle.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/500
+     */
+    HttpStatus[HttpStatus["InternalServerError"] = 500] = "InternalServerError";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/501
+     */
+    HttpStatus[HttpStatus["NotImplemented"] = 501] = "NotImplemented";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/502
+     */
+    HttpStatus[HttpStatus["BadGateway"] = 502] = "BadGateway";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/503
+     */
+    HttpStatus[HttpStatus["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    /**
+     * This error response is given when the server is acting as a gateway and cannot get a response
+     * in time.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/504
+     */
+    HttpStatus[HttpStatus["GatewayTimeout"] = 504] = "GatewayTimeout";
+    /**
+     * The HTTP version used in the request is not supported by the server.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/505
+     */
+    HttpStatus[HttpStatus["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+    /**
+     * 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.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/506
+     */
+    HttpStatus[HttpStatus["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    /**
+     * The method could not be performed on the resource because the server is unable to store the
+     * representation needed to successfully complete the request.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/507
+     */
+    HttpStatus[HttpStatus["InsufficientStorage"] = 507] = "InsufficientStorage";
+    /**
+     * The server detected an infinite loop while processing the request.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/508
+     */
+    HttpStatus[HttpStatus["LoopDetected"] = 508] = "LoopDetected";
+    /**
+     * Further extensions to the request are required for the server to fulfill it.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/510
+     */
+    HttpStatus[HttpStatus["NotExtended"] = 510] = "NotExtended";
+    /**
+     * Indicates that the client needs to authenticate to gain network access.
+     *
+     * See https://developer.mozilla.org/docs/Web/HTTP/Status/511
+     */
+    HttpStatus[HttpStatus["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(HttpStatus || (HttpStatus = {}));
+export var HttpStatusCategory;
+(function (HttpStatusCategory) {
+    HttpStatusCategory["Information"] = "information";
+    HttpStatusCategory["Success"] = "success";
+    HttpStatusCategory["Redirect"] = "redirect";
+    HttpStatusCategory["ClientError"] = "clientError";
+    HttpStatusCategory["ServerError"] = "serverError";
+})(HttpStatusCategory || (HttpStatusCategory = {}));
+export const httpStatusByCategory = {
+    [HttpStatusCategory.Information]: [
+        HttpStatus.Continue,
+        HttpStatus.SwitchingProtocols,
+        HttpStatus.Processing,
+        HttpStatus.EarlyHints,
+    ],
+    [HttpStatusCategory.Success]: [
+        HttpStatus.Ok,
+        HttpStatus.Created,
+        HttpStatus.Accepted,
+        HttpStatus.NonAuthoritativeInformation,
+        HttpStatus.NoContent,
+        HttpStatus.ResetContent,
+        HttpStatus.PartialContent,
+        HttpStatus.MultiStatus,
+        HttpStatus.AlreadyReported,
+        HttpStatus.ImUsed,
+    ],
+    [HttpStatusCategory.Redirect]: [
+        HttpStatus.MultipleChoices,
+        HttpStatus.MovedPermanently,
+        HttpStatus.Found,
+        HttpStatus.SeeOther,
+        HttpStatus.NotModified,
+        HttpStatus.UseProxy,
+        HttpStatus.Unused,
+        HttpStatus.TemporaryRedirect,
+        HttpStatus.PermanentRedirect,
+    ],
+    [HttpStatusCategory.ClientError]: [
+        HttpStatus.BadRequest,
+        HttpStatus.Unauthorized,
+        HttpStatus.PaymentRequired,
+        HttpStatus.Forbidden,
+        HttpStatus.NotFound,
+        HttpStatus.MethodNotAllowed,
+        HttpStatus.NotAcceptable,
+        HttpStatus.ProxyAuthenticationRequired,
+        HttpStatus.RequestTimeout,
+        HttpStatus.Conflict,
+        HttpStatus.Gone,
+        HttpStatus.LengthRequired,
+        HttpStatus.PreconditionFailed,
+        HttpStatus.PayloadTooLarge,
+        HttpStatus.UriTooLong,
+        HttpStatus.UnsupportedMediaType,
+        HttpStatus.RangeNotSatisfiable,
+        HttpStatus.ExpectationFailed,
+        HttpStatus.ImATeapot,
+        HttpStatus.MisdirectedRequest,
+        HttpStatus.UnprocessableContent,
+        HttpStatus.Locked,
+        HttpStatus.FailedDependency,
+        HttpStatus.TooEarly,
+        HttpStatus.UpgradeRequired,
+        HttpStatus.PreconditionRequired,
+        HttpStatus.TooManyRequests,
+        HttpStatus.RequestHeaderFieldsTooLarge,
+        HttpStatus.UnavailableForLegalReasons,
+    ],
+    [HttpStatusCategory.ServerError]: [
+        HttpStatus.InternalServerError,
+        HttpStatus.NotImplemented,
+        HttpStatus.BadGateway,
+        HttpStatus.ServiceUnavailable,
+        HttpStatus.GatewayTimeout,
+        HttpStatus.HttpVersionNotSupported,
+        HttpStatus.VariantAlsoNegotiates,
+        HttpStatus.InsufficientStorage,
+        HttpStatus.LoopDetected,
+        HttpStatus.NotExtended,
+        HttpStatus.NetworkAuthenticationRequired,
+    ],
+};

package/dist/augments/narrow-type.d.ts

@@ -0,0 +1,2 @@
+export type NarrowToExpected<Actual, Expected> = Extract<Expected, Actual> extends never ? Extract<Actual, Expected> extends never ? Expected extends Actual ? Expected : never : Extract<Actual, Expected> : Extract<Expected, Actual>;
+export type NarrowToActual<Actual, Expected> = Extract<Actual, Expected> extends never ? Extract<Expected, Actual> extends never ? Expected extends Actual ? Expected : never : Extract<Expected, Actual> : Extract<Actual, Expected>;

package/dist/augments/narrow-type.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/object/generic-object-type.d.ts

@@ -0,0 +1,2 @@
+export type AnyObject = Record<PropertyKey, any>;
+export type UnknownObject = Record<PropertyKey, unknown>;

package/dist/augments/object/generic-object-type.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/object/object-keys.d.ts

@@ -0,0 +1,7 @@
+export declare function getObjectTypedKeys<const ObjectGeneric>(input: ObjectGeneric): Array<keyof ObjectGeneric>;
+export type ExtractKeysWithMatchingValues<OriginalObject extends object, Matcher> = keyof {
+    [Prop in keyof OriginalObject as OriginalObject[Prop] extends Matcher ? Prop : never]: Prop;
+};
+export type ExcludeKeysWithMatchingValues<OriginalObject extends object, Matcher> = keyof {
+    [Prop in keyof OriginalObject as OriginalObject[Prop] extends Matcher ? never : Prop]: Prop;
+};

package/dist/augments/object/object-keys.js

@@ -0,0 +1,14 @@
+export function getObjectTypedKeys(input) {
+    let reflectKeys;
+    try {
+        reflectKeys = Reflect.ownKeys(input);
+    }
+    catch {
+        // do nothing
+    }
+    return (reflectKeys ??
+        [
+            ...Object.keys(input),
+            ...Object.getOwnPropertySymbols(input),
+        ]);
+}

package/dist/augments/object/object-value-types.d.ts

@@ -0,0 +1,3 @@
+import type { CompleteRequire } from './required-keys.js';
+export type Values<T> = CompleteRequire<T>[keyof T];
+export type ValueAtRequiredKey<Parent, Key extends keyof Parent> = CompleteRequire<Parent>[Key];

package/dist/augments/object/object-value-types.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/object/required-keys.d.ts

@@ -0,0 +1,36 @@
+import { Except, Simplify } from 'type-fest';
+export type { SetRequired } from 'type-fest';
+/**
+ * Same as the Required<> built-in type helper but this requires that each property be present and
+ * be not null.
+ */
+export type RequiredAndNotNull<T> = {
+    [P in keyof CompleteRequire<T>]-?: NonNullable<T[P]>;
+};
+/**
+ * Require only a subset of object properties and require that they be not null. This is
+ * particularly useful in conjunction with the "exactOptionalPropertyTypes" tsconfig flag.
+ */
+export type SetRequiredAndNotNull<T, K extends keyof T> = Omit<T, K> & CompleteRequire<{
+    [PropertyName in K]: NonNullable<T[PropertyName]>;
+}>;
+export type SetOptionalAndNullable<OriginalObjectGeneric, OptionalKeysGeneric extends keyof OriginalObjectGeneric> = Simplify<Except<OriginalObjectGeneric, OptionalKeysGeneric> & {
+    [PropKey in OptionalKeysGeneric]?: OriginalObjectGeneric[PropKey] | null | undefined;
+}>;
+/**
+ * Modified version of `RequiredKeys` from `type-fest` that does not require `BaseType` to extends
+ * `object`.
+ */
+export type RequiredKeysOf<BaseType> = Exclude<{
+    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
+}[keyof BaseType], undefined>;
+/**
+ * Requires every part of an object, even the indexed keys. This is needed because
+ * `Required<Partial<T>>` doesn't fully remove `| undefined` from indexed keys when the
+ * `noUncheckedIndexedAccess` TSConfig compiler option is enabled.
+ *
+ * @category Object:Common
+ */
+export type CompleteRequire<Parent> = {
+    [Prop in keyof Parent]-?: Parent extends Partial<Record<Prop, infer V>> ? V : never;
+};

package/dist/augments/object/required-keys.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/object/stringify.d.ts

@@ -0,0 +1 @@
+export declare function stringify(input: unknown): string;

package/dist/augments/object/stringify.js

@@ -0,0 +1,9 @@
+import JSON5 from 'json5';
+export function stringify(input) {
+    try {
+        return JSON5.stringify(input);
+    }
+    catch {
+        return String(input);
+    }
+}

package/dist/augments/overwrite-type.d.ts

@@ -0,0 +1,2 @@
+/** Replace properties in T with properties in U. */
+export type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;

package/dist/augments/overwrite-type.js

@@ -0,0 +1 @@
+export {};