response-objects - npm Package Compare versions

Comparing version 3.0.3 to 3.1.0

dist/index.d.ts

@@ -16,65 +16,128 @@ export interface BaseResponseObject<T> {
 }
+declare function R(code: number): ResponseObject<void>;
 declare function R<T>(code: number, body?: T, headers?: Headers): ResponseObject<T>;
 declare namespace R {
+    function Continue(): ResponseObject<void>;
     function Continue<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function SwitchingProtocols(): ResponseObject<void>;
     function SwitchingProtocols<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Processing(): ResponseObject<void>;
     function Processing<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function EarlyHints(): ResponseObject<void>;
     function EarlyHints<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function OK(): ResponseObject<void>;
     function OK<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Created(): ResponseObject<void>;
     function Created<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Accepted(): ResponseObject<void>;
     function Accepted<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NonAuthoritativeInformation(): ResponseObject<void>;
     function NonAuthoritativeInformation<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NoContent(): ResponseObject<void>;
     function NoContent<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function ResetContent(): ResponseObject<void>;
     function ResetContent<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function PartialContent(): ResponseObject<void>;
     function PartialContent<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function MultiStatus(): ResponseObject<void>;
     function MultiStatus<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function AlreadyReported(): ResponseObject<void>;
     function AlreadyReported<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function IMUsed(): ResponseObject<void>;
     function IMUsed<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function MultipleChoices(): ResponseObject<void>;
     function MultipleChoices<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function MovedPermanently(): ResponseObject<void>;
     function MovedPermanently<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Found(): ResponseObject<void>;
     function Found<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function SeeOther(): ResponseObject<void>;
     function SeeOther<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NotModified(): ResponseObject<void>;
     function NotModified<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function UseProxy(): ResponseObject<void>;
     function UseProxy<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function TemporaryRedirect(): ResponseObject<void>;
     function TemporaryRedirect<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function PermanentRedirect(): ResponseObject<void>;
     function PermanentRedirect<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function BadRequest(): ResponseObject<void>;
     function BadRequest<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Unauthorized(): ResponseObject<void>;
     function Unauthorized<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function PaymentRequired(): ResponseObject<void>;
     function PaymentRequired<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Forbidden(): ResponseObject<void>;
     function Forbidden<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NotFound(): ResponseObject<void>;
     function NotFound<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function MethodNotAllowed(): ResponseObject<void>;
     function MethodNotAllowed<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NotAcceptable(): ResponseObject<void>;
     function NotAcceptable<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function ProxyAuthenticationRequired(): ResponseObject<void>;
     function ProxyAuthenticationRequired<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function RequestTimeout(): ResponseObject<void>;
     function RequestTimeout<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Conflict(): ResponseObject<void>;
     function Conflict<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Gone(): ResponseObject<void>;
     function Gone<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function LengthRequired(): ResponseObject<void>;
     function LengthRequired<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function PreconditionFailed(): ResponseObject<void>;
     function PreconditionFailed<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function PayloadTooLarge(): ResponseObject<void>;
     function PayloadTooLarge<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function URITooLong(): ResponseObject<void>;
     function URITooLong<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function UnsupportedMediaType(): ResponseObject<void>;
     function UnsupportedMediaType<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function RangeNotSatisfiable(): ResponseObject<void>;
     function RangeNotSatisfiable<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function ExpectationFailed(): ResponseObject<void>;
     function ExpectationFailed<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function MisdirectedRequest(): ResponseObject<void>;
     function MisdirectedRequest<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function UnprocessableEntity(): ResponseObject<void>;
     function UnprocessableEntity<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function Locked(): ResponseObject<void>;
     function Locked<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function FailedDependency(): ResponseObject<void>;
     function FailedDependency<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function UnorderedCollection(): ResponseObject<void>;
     function UnorderedCollection<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function UpgradeRequired(): ResponseObject<void>;
     function UpgradeRequired<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function PreconditionRequired(): ResponseObject<void>;
     function PreconditionRequired<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function TooManyRequests(): ResponseObject<void>;
     function TooManyRequests<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function RequestHeaderFieldsTooLarge(): ResponseObject<void>;
     function RequestHeaderFieldsTooLarge<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function UnavailableForLegalReasons(): ResponseObject<void>;
     function UnavailableForLegalReasons<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function InternalServerError(): ResponseObject<void>;
     function InternalServerError<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NotImplemented(): ResponseObject<void>;
     function NotImplemented<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function BadGateway(): ResponseObject<void>;
     function BadGateway<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function ServiceUnavailable(): ResponseObject<void>;
     function ServiceUnavailable<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function GatewayTimeout(): ResponseObject<void>;
     function GatewayTimeout<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function HTTPVersionNotSupported(): ResponseObject<void>;
     function HTTPVersionNotSupported<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function VariantAlsoNegotiates(): ResponseObject<void>;
     function VariantAlsoNegotiates<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function InsufficientStorage(): ResponseObject<void>;
     function InsufficientStorage<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function LoopDetected(): ResponseObject<void>;
     function LoopDetected<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function BandwidthLimitExceeded(): ResponseObject<void>;
     function BandwidthLimitExceeded<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NotExtended(): ResponseObject<void>;
     function NotExtended<T>(body?: T, headers?: Headers): ResponseObject<T>;
+    function NetworkAuthenticationRequired(): ResponseObject<void>;
     function NetworkAuthenticationRequired<T>(body?: T, headers?: Headers): ResponseObject<T>;
@@ -81,0 +144,0 @@ const Ok: typeof OK;

package.json

 {
   "name": "response-objects",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "simple value objects representing HTTP responses",
@@ -5,0 +5,0 @@ "main": "dist/index.js",

script/generate_namespace.js

@@ -48,2 +48,4 @@ const { STATUS_CODES } = require("http");
 const rFunction = `
+function R(code: number): ResponseObject<void>
+function R<T> (code: number, body?: T, headers?: Headers): ResponseObject<T>
 function R<T> (code: number, body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -81,2 +83,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
     return `
+    export function ${name}(): ResponseObject<void>;
+    export function ${name}<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function ${name}<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -94,2 +98,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
   return `
+  export function ${name}(): ResponseObject<void>;
+  export function ${name}<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function ${name}<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -96,0 +102,0 @@ if (responses.has(body as any)) throw new Error("Object is already a response");

src/index.ts

@@ -36,2 +36,4 @@ import { STATUS_CODES } from "http";
 
+function R(code: number): ResponseObject<void>
+function R<T> (code: number, body?: T, headers?: Headers): ResponseObject<T>
 function R<T> (code: number, body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -55,2 +57,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
   
+  export function Continue(): ResponseObject<void>;
+  export function Continue<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function Continue<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -66,2 +70,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function SwitchingProtocols(): ResponseObject<void>;
+  export function SwitchingProtocols<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function SwitchingProtocols<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -77,2 +83,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function Processing(): ResponseObject<void>;
+  export function Processing<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function Processing<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -88,2 +96,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function EarlyHints(): ResponseObject<void>;
+  export function EarlyHints<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function EarlyHints<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -99,2 +109,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function OK(): ResponseObject<void>;
+  export function OK<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function OK<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -110,2 +122,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function Created(): ResponseObject<void>;
+  export function Created<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function Created<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -121,2 +135,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function Accepted(): ResponseObject<void>;
+  export function Accepted<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function Accepted<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -132,2 +148,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function NonAuthoritativeInformation(): ResponseObject<void>;
+  export function NonAuthoritativeInformation<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function NonAuthoritativeInformation<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -143,2 +161,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function NoContent(): ResponseObject<void>;
+  export function NoContent<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function NoContent<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -154,2 +174,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function ResetContent(): ResponseObject<void>;
+  export function ResetContent<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function ResetContent<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -165,2 +187,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function PartialContent(): ResponseObject<void>;
+  export function PartialContent<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function PartialContent<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -176,2 +200,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function MultiStatus(): ResponseObject<void>;
+  export function MultiStatus<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function MultiStatus<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -187,2 +213,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function AlreadyReported(): ResponseObject<void>;
+  export function AlreadyReported<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function AlreadyReported<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -198,2 +226,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function IMUsed(): ResponseObject<void>;
+  export function IMUsed<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function IMUsed<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -209,2 +239,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function MultipleChoices(): ResponseObject<void>;
+  export function MultipleChoices<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function MultipleChoices<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -220,2 +252,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function MovedPermanently(): ResponseObject<void>;
+  export function MovedPermanently<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function MovedPermanently<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -231,2 +265,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function Found(): ResponseObject<void>;
+  export function Found<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function Found<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -242,2 +278,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function SeeOther(): ResponseObject<void>;
+  export function SeeOther<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function SeeOther<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -253,2 +291,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function NotModified(): ResponseObject<void>;
+  export function NotModified<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function NotModified<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -264,2 +304,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function UseProxy(): ResponseObject<void>;
+  export function UseProxy<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function UseProxy<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -275,2 +317,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function TemporaryRedirect(): ResponseObject<void>;
+  export function TemporaryRedirect<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function TemporaryRedirect<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -286,2 +330,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+  export function PermanentRedirect(): ResponseObject<void>;
+  export function PermanentRedirect<T> (body?: T, headers?: Headers): ResponseObject<T>
   export function PermanentRedirect<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -297,2 +343,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function BadRequest(): ResponseObject<void>;
+    export function BadRequest<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function BadRequest<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -309,2 +357,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function Unauthorized(): ResponseObject<void>;
+    export function Unauthorized<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function Unauthorized<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -321,2 +371,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function PaymentRequired(): ResponseObject<void>;
+    export function PaymentRequired<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function PaymentRequired<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -333,2 +385,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function Forbidden(): ResponseObject<void>;
+    export function Forbidden<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function Forbidden<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -345,2 +399,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function NotFound(): ResponseObject<void>;
+    export function NotFound<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function NotFound<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -357,2 +413,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function MethodNotAllowed(): ResponseObject<void>;
+    export function MethodNotAllowed<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function MethodNotAllowed<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -369,2 +427,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function NotAcceptable(): ResponseObject<void>;
+    export function NotAcceptable<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function NotAcceptable<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -381,2 +441,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function ProxyAuthenticationRequired(): ResponseObject<void>;
+    export function ProxyAuthenticationRequired<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function ProxyAuthenticationRequired<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -393,2 +455,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function RequestTimeout(): ResponseObject<void>;
+    export function RequestTimeout<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function RequestTimeout<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -405,2 +469,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function Conflict(): ResponseObject<void>;
+    export function Conflict<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function Conflict<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -417,2 +483,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function Gone(): ResponseObject<void>;
+    export function Gone<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function Gone<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -429,2 +497,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function LengthRequired(): ResponseObject<void>;
+    export function LengthRequired<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function LengthRequired<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -441,2 +511,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function PreconditionFailed(): ResponseObject<void>;
+    export function PreconditionFailed<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function PreconditionFailed<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -453,2 +525,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function PayloadTooLarge(): ResponseObject<void>;
+    export function PayloadTooLarge<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function PayloadTooLarge<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -465,2 +539,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function URITooLong(): ResponseObject<void>;
+    export function URITooLong<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function URITooLong<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -477,2 +553,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function UnsupportedMediaType(): ResponseObject<void>;
+    export function UnsupportedMediaType<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function UnsupportedMediaType<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -489,2 +567,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function RangeNotSatisfiable(): ResponseObject<void>;
+    export function RangeNotSatisfiable<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function RangeNotSatisfiable<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -501,2 +581,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function ExpectationFailed(): ResponseObject<void>;
+    export function ExpectationFailed<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function ExpectationFailed<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -513,2 +595,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function MisdirectedRequest(): ResponseObject<void>;
+    export function MisdirectedRequest<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function MisdirectedRequest<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -525,2 +609,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function UnprocessableEntity(): ResponseObject<void>;
+    export function UnprocessableEntity<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function UnprocessableEntity<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -537,2 +623,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function Locked(): ResponseObject<void>;
+    export function Locked<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function Locked<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -549,2 +637,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function FailedDependency(): ResponseObject<void>;
+    export function FailedDependency<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function FailedDependency<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -561,2 +651,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function UnorderedCollection(): ResponseObject<void>;
+    export function UnorderedCollection<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function UnorderedCollection<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -573,2 +665,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function UpgradeRequired(): ResponseObject<void>;
+    export function UpgradeRequired<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function UpgradeRequired<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -585,2 +679,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function PreconditionRequired(): ResponseObject<void>;
+    export function PreconditionRequired<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function PreconditionRequired<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -597,2 +693,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function TooManyRequests(): ResponseObject<void>;
+    export function TooManyRequests<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function TooManyRequests<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -609,2 +707,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function RequestHeaderFieldsTooLarge(): ResponseObject<void>;
+    export function RequestHeaderFieldsTooLarge<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function RequestHeaderFieldsTooLarge<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -621,2 +721,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function UnavailableForLegalReasons(): ResponseObject<void>;
+    export function UnavailableForLegalReasons<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function UnavailableForLegalReasons<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -633,2 +735,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function InternalServerError(): ResponseObject<void>;
+    export function InternalServerError<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function InternalServerError<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -645,2 +749,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function NotImplemented(): ResponseObject<void>;
+    export function NotImplemented<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function NotImplemented<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -657,2 +763,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function BadGateway(): ResponseObject<void>;
+    export function BadGateway<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function BadGateway<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -669,2 +777,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function ServiceUnavailable(): ResponseObject<void>;
+    export function ServiceUnavailable<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function ServiceUnavailable<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -681,2 +791,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function GatewayTimeout(): ResponseObject<void>;
+    export function GatewayTimeout<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function GatewayTimeout<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -693,2 +805,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function HTTPVersionNotSupported(): ResponseObject<void>;
+    export function HTTPVersionNotSupported<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function HTTPVersionNotSupported<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -705,2 +819,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function VariantAlsoNegotiates(): ResponseObject<void>;
+    export function VariantAlsoNegotiates<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function VariantAlsoNegotiates<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -717,2 +833,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function InsufficientStorage(): ResponseObject<void>;
+    export function InsufficientStorage<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function InsufficientStorage<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -729,2 +847,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function LoopDetected(): ResponseObject<void>;
+    export function LoopDetected<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function LoopDetected<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -741,2 +861,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function BandwidthLimitExceeded(): ResponseObject<void>;
+    export function BandwidthLimitExceeded<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function BandwidthLimitExceeded<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -753,2 +875,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function NotExtended(): ResponseObject<void>;
+    export function NotExtended<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function NotExtended<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -765,2 +889,4 @@ if (responses.has(body as any)) throw new Error("Object is already a response");
 
+    export function NetworkAuthenticationRequired(): ResponseObject<void>;
+    export function NetworkAuthenticationRequired<T> (body?: T, headers?: Headers): ResponseObject<T>
     export function NetworkAuthenticationRequired<T> (body?: T, headers: Headers = {}): ResponseObject<T> {
@@ -767,0 +893,0 @@ if (responses.has(body as any)) throw new Error("Object is already a response");

test/import.ts

@@ -8,1 +8,4 @@ import * as Rstar from "../src";
 console.log("import check passed")
+
+const foo = R.NotFound();
+foo.toJSON()

No alert changes

Improved metrics

Total package byte prevSize

141131

increased by10.15%

Lines of code

2098

increased by10.3%

No dependency changes