@api-ts/io-ts-http - npm Package Compare versions

Comparing version 2.2.0 to 2.3.0

dist/src/httpResponse.d.ts

@@ -5,3 +5,245 @@ import * as t from 'io-ts';
 };
+export declare const Response: {
+    continue: <T>(payload: T) => {
+        type: 100;
+        payload: T;
+    };
+    switchingProtocols: <T_1>(payload: T_1) => {
+        type: 101;
+        payload: T_1;
+    };
+    processing: <T_2>(payload: T_2) => {
+        type: 102;
+        payload: T_2;
+    };
+    ok: <T_3>(payload: T_3) => {
+        type: 200;
+        payload: T_3;
+    };
+    created: <T_4>(payload: T_4) => {
+        type: 201;
+        payload: T_4;
+    };
+    accepted: <T_5>(payload: T_5) => {
+        type: 202;
+        payload: T_5;
+    };
+    nonAuthoritativeInformation: <T_6>(payload: T_6) => {
+        type: 203;
+        payload: T_6;
+    };
+    noContent: <T_7>(payload: T_7) => {
+        type: 204;
+        payload: T_7;
+    };
+    resetContent: <T_8>(payload: T_8) => {
+        type: 205;
+        payload: T_8;
+    };
+    partialContent: <T_9>(payload: T_9) => {
+        type: 206;
+        payload: T_9;
+    };
+    multiStatus: <T_10>(payload: T_10) => {
+        type: 207;
+        payload: T_10;
+    };
+    alreadyReported: <T_11>(payload: T_11) => {
+        type: 208;
+        payload: T_11;
+    };
+    imUsed: <T_12>(payload: T_12) => {
+        type: 226;
+        payload: T_12;
+    };
+    multipleChoices: <T_13>(payload: T_13) => {
+        type: 300;
+        payload: T_13;
+    };
+    movedPermanently: <T_14>(payload: T_14) => {
+        type: 301;
+        payload: T_14;
+    };
+    found: <T_15>(payload: T_15) => {
+        type: 302;
+        payload: T_15;
+    };
+    seeOther: <T_16>(payload: T_16) => {
+        type: 303;
+        payload: T_16;
+    };
+    notModified: <T_17>(payload: T_17) => {
+        type: 304;
+        payload: T_17;
+    };
+    temporaryRedirect: <T_18>(payload: T_18) => {
+        type: 307;
+        payload: T_18;
+    };
+    permanentRedirect: <T_19>(payload: T_19) => {
+        type: 308;
+        payload: T_19;
+    };
+    invalidRequest: <T_20>(payload: T_20) => {
+        type: 400;
+        payload: T_20;
+    };
+    unauthenticated: <T_21>(payload: T_21) => {
+        type: 401;
+        payload: T_21;
+    };
+    paymentRequired: <T_22>(payload: T_22) => {
+        type: 402;
+        payload: T_22;
+    };
+    permissionDenied: <T_23>(payload: T_23) => {
+        type: 403;
+        payload: T_23;
+    };
+    notFound: <T_24>(payload: T_24) => {
+        type: 404;
+        payload: T_24;
+    };
+    methodNotAllowed: <T_25>(payload: T_25) => {
+        type: 405;
+        payload: T_25;
+    };
+    notAcceptable: <T_26>(payload: T_26) => {
+        type: 406;
+        payload: T_26;
+    };
+    proxyAuthenticationRequired: <T_27>(payload: T_27) => {
+        type: 407;
+        payload: T_27;
+    };
+    requestTimeout: <T_28>(payload: T_28) => {
+        type: 408;
+        payload: T_28;
+    };
+    conflict: <T_29>(payload: T_29) => {
+        type: 409;
+        payload: T_29;
+    };
+    gone: <T_30>(payload: T_30) => {
+        type: 410;
+        payload: T_30;
+    };
+    lengthRequired: <T_31>(payload: T_31) => {
+        type: 411;
+        payload: T_31;
+    };
+    preconditionFailed: <T_32>(payload: T_32) => {
+        type: 412;
+        payload: T_32;
+    };
+    contentTooLarge: <T_33>(payload: T_33) => {
+        type: 413;
+        payload: T_33;
+    };
+    uriTooLong: <T_34>(payload: T_34) => {
+        type: 414;
+        payload: T_34;
+    };
+    unsupportedMediaType: <T_35>(payload: T_35) => {
+        type: 415;
+        payload: T_35;
+    };
+    rangeNotSatisfiable: <T_36>(payload: T_36) => {
+        type: 416;
+        payload: T_36;
+    };
+    exceptionFailed: <T_37>(payload: T_37) => {
+        type: 417;
+        payload: T_37;
+    };
+    imATeapot: <T_38>(payload: T_38) => {
+        type: 418;
+        payload: T_38;
+    };
+    misdirectedRequest: <T_39>(payload: T_39) => {
+        type: 421;
+        payload: T_39;
+    };
+    unprocessableContent: <T_40>(payload: T_40) => {
+        type: 422;
+        payload: T_40;
+    };
+    locked: <T_41>(payload: T_41) => {
+        type: 423;
+        payload: T_41;
+    };
+    failedDependency: <T_42>(payload: T_42) => {
+        type: 424;
+        payload: T_42;
+    };
+    tooEarly: <T_43>(payload: T_43) => {
+        type: 425;
+        payload: T_43;
+    };
+    upgradeRequired: <T_44>(payload: T_44) => {
+        type: 426;
+        payload: T_44;
+    };
+    preconditionRequired: <T_45>(payload: T_45) => {
+        type: 428;
+        payload: T_45;
+    };
+    rateLimitExceeded: <T_46>(payload: T_46) => {
+        type: 429;
+        payload: T_46;
+    };
+    requestHeaderFieldsTooLarge: <T_47>(payload: T_47) => {
+        type: 431;
+        payload: T_47;
+    };
+    unavailableForLegalReasons: <T_48>(payload: T_48) => {
+        type: 451;
+        payload: T_48;
+    };
+    internalError: <T_49>(payload: T_49) => {
+        type: 500;
+        payload: T_49;
+    };
+    notImplemented: <T_50>(payload: T_50) => {
+        type: 501;
+        payload: T_50;
+    };
+    badGateway: <T_51>(payload: T_51) => {
+        type: 502;
+        payload: T_51;
+    };
+    serviceUnavailable: <T_52>(payload: T_52) => {
+        type: 503;
+        payload: T_52;
+    };
+    gatewayTimeout: <T_53>(payload: T_53) => {
+        type: 504;
+        payload: T_53;
+    };
+    httpVersionNotSupported: <T_54>(payload: T_54) => {
+        type: 505;
+        payload: T_54;
+    };
+    variantAlsoNegotiates: <T_55>(payload: T_55) => {
+        type: 506;
+        payload: T_55;
+    };
+    insufficientStorage: <T_56>(payload: T_56) => {
+        type: 507;
+        payload: T_56;
+    };
+    loopDetected: <T_57>(payload: T_57) => {
+        type: 508;
+        payload: T_57;
+    };
+    notExtended: <T_58>(payload: T_58) => {
+        type: 510;
+        payload: T_58;
+    };
+    networkAuthenticationRequired: <T_59>(payload: T_59) => {
+        type: 511;
+        payload: T_59;
+    };
+};
 export declare type ResponseTypeForStatus<Response extends HttpResponse, S extends keyof Response> = Response[S] extends t.Mixed ? t.TypeOf<Response[S]> : never;
 //# sourceMappingURL=httpResponse.d.ts.map

dist/src/httpResponse.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+const statusCode_1 = require("./statusCode");
+const responseFunction = (status) => (payload) => ({ type: statusCode_1.KeyToHttpStatus[status], payload });
+exports.Response = {
+    continue: responseFunction('continue'),
+    switchingProtocols: responseFunction('switchingProtocols'),
+    processing: responseFunction('processing'),
+    ok: responseFunction('ok'),
+    created: responseFunction('created'),
+    accepted: responseFunction('accepted'),
+    nonAuthoritativeInformation: responseFunction('nonAuthoritativeInformation'),
+    noContent: responseFunction('noContent'),
+    resetContent: responseFunction('resetContent'),
+    partialContent: responseFunction('partialContent'),
+    multiStatus: responseFunction('multiStatus'),
+    alreadyReported: responseFunction('alreadyReported'),
+    imUsed: responseFunction('imUsed'),
+    multipleChoices: responseFunction('multipleChoices'),
+    movedPermanently: responseFunction('movedPermanently'),
+    found: responseFunction('found'),
+    seeOther: responseFunction('seeOther'),
+    notModified: responseFunction('notModified'),
+    temporaryRedirect: responseFunction('temporaryRedirect'),
+    permanentRedirect: responseFunction('permanentRedirect'),
+    invalidRequest: responseFunction('invalidRequest'),
+    unauthenticated: responseFunction('unauthenticated'),
+    paymentRequired: responseFunction('paymentRequired'),
+    permissionDenied: responseFunction('permissionDenied'),
+    notFound: responseFunction('notFound'),
+    methodNotAllowed: responseFunction('methodNotAllowed'),
+    notAcceptable: responseFunction('notAcceptable'),
+    proxyAuthenticationRequired: responseFunction('proxyAuthenticationRequired'),
+    requestTimeout: responseFunction('requestTimeout'),
+    conflict: responseFunction('conflict'),
+    gone: responseFunction('gone'),
+    lengthRequired: responseFunction('lengthRequired'),
+    preconditionFailed: responseFunction('preconditionFailed'),
+    contentTooLarge: responseFunction('contentTooLarge'),
+    uriTooLong: responseFunction('uriTooLong'),
+    unsupportedMediaType: responseFunction('unsupportedMediaType'),
+    rangeNotSatisfiable: responseFunction('rangeNotSatisfiable'),
+    exceptionFailed: responseFunction('exceptionFailed'),
+    imATeapot: responseFunction('imATeapot'),
+    misdirectedRequest: responseFunction('misdirectedRequest'),
+    unprocessableContent: responseFunction('unprocessableContent'),
+    locked: responseFunction('locked'),
+    failedDependency: responseFunction('failedDependency'),
+    tooEarly: responseFunction('tooEarly'),
+    upgradeRequired: responseFunction('upgradeRequired'),
+    preconditionRequired: responseFunction('preconditionRequired'),
+    rateLimitExceeded: responseFunction('rateLimitExceeded'),
+    requestHeaderFieldsTooLarge: responseFunction('requestHeaderFieldsTooLarge'),
+    unavailableForLegalReasons: responseFunction('unavailableForLegalReasons'),
+    internalError: responseFunction('internalError'),
+    notImplemented: responseFunction('notImplemented'),
+    badGateway: responseFunction('badGateway'),
+    serviceUnavailable: responseFunction('serviceUnavailable'),
+    gatewayTimeout: responseFunction('gatewayTimeout'),
+    httpVersionNotSupported: responseFunction('httpVersionNotSupported'),
+    variantAlsoNegotiates: responseFunction('variantAlsoNegotiates'),
+    insufficientStorage: responseFunction('insufficientStorage'),
+    loopDetected: responseFunction('loopDetected'),
+    notExtended: responseFunction('notExtended'),
+    networkAuthenticationRequired: responseFunction('networkAuthenticationRequired'),
+};
 //# sourceMappingURL=httpResponse.js.map

package.json

 {
   "name": "@api-ts/io-ts-http",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Types for (de)serializing HTTP requests from both the client and server side",
@@ -5,0 +5,0 @@ "author": "Patrick McLaughlin <[e-mail]>",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

62206

increased by24.53%

Lines of code

901

increased by51.68%

No dependency changes