@tsoa-next/runtime 7.1.0

package/dist/routeGeneration/templates/templateService.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateService = void 0;
+const templateHelpers_1 = require("../templateHelpers");
+class TemplateService {
+    models;
+    config;
+    validationService;
+    constructor(models, config) {
+        this.models = models;
+        this.config = config;
+        this.validationService = new templateHelpers_1.ValidationService(models, config);
+    }
+    isController(object) {
+        return 'getHeaders' in object && 'getStatus' in object && 'setStatus' in object;
+    }
+    buildPromise(methodName, controller, validatedArgs) {
+        const ownPrototype = Object.getPrototypeOf(controller);
+        let prototype = ownPrototype;
+        let descriptor;
+        // Search up the prototype chain so inherited controller actions can be dispatched.
+        // We stop at Object.prototype because methods above that level are not user actions.
+        while (prototype && prototype !== Object.prototype) {
+            descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+            if (descriptor?.value && typeof descriptor.value === 'function') {
+                break;
+            }
+            prototype = Object.getPrototypeOf(prototype);
+        }
+        // Keep previous behavior when nothing is found by allowing the same
+        // descriptor access failure path to occur on the original prototype.
+        const resolvedDescriptor = descriptor || Object.getOwnPropertyDescriptor(ownPrototype, methodName);
+        return resolvedDescriptor.value.apply(controller, validatedArgs);
+    }
+}
+exports.TemplateService = TemplateService;
+//# sourceMappingURL=templateService.js.map

package/dist/routeGeneration/templates/templateService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateService.js","sourceRoot":"","sources":["../../../src/routeGeneration/templates/templateService.ts"],"names":[],"mappings":";;;AAEA,wDAAsD;AAGtD,MAAsB,eAAe;IAId;IACA;IAJX,iBAAiB,CAAmB;IAE9C,YACqB,MAAwB,EACxB,MAAuB;QADvB,WAAM,GAAN,MAAM,CAAkB;QACxB,WAAM,GAAN,MAAM,CAAiB;QAE1C,IAAI,CAAC,iBAAiB,GAAG,IAAI,mCAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChE,CAAC;IAQS,YAAY,CAAC,MAA2B;QAChD,OAAO,YAAY,IAAI,MAAM,IAAI,WAAW,IAAI,MAAM,IAAI,WAAW,IAAI,MAAM,CAAA;IACjF,CAAC;IAES,YAAY,CAAC,UAAkB,EAAE,UAA+B,EAAE,aAAkB;QAC5F,MAAM,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAA;QACtD,IAAI,SAAS,GAAkB,YAAY,CAAA;QAC3C,IAAI,UAA0C,CAAA;QAE9C,mFAAmF;QACnF,qFAAqF;QACrF,OAAO,SAAS,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;YACnD,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;YACnE,IAAI,UAAU,EAAE,KAAK,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;gBAChE,MAAK;YACP,CAAC;YAED,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAA;QAC9C,CAAC;QAED,oEAAoE;QACpE,qEAAqE;QACrE,MAAM,kBAAkB,GAAG,UAAU,IAAI,MAAM,CAAC,wBAAwB,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;QAClG,OAAQ,kBAAmB,CAAC,KAA0C,CAAC,KAAK,CAAC,UAAU,EAAE,aAAa,CAAC,CAAA;IACzG,CAAC;CACF;AAzCD,0CAyCC"}

package/dist/routeGeneration/tsoa-route.d.ts

@@ -0,0 +1,56 @@
+import { Tsoa } from './../metadataGeneration/tsoa';
+/**
+ * For Swagger, additionalProperties is implicitly allowed. So use this function to clarify that undefined should be associated with allowing additional properties
+ * @param test if this is undefined then you should interpret it as a "yes"
+ */
+export declare function isDefaultForAdditionalPropertiesAllowed(test: TsoaRoute.RefObjectModelSchema['additionalProperties']): test is undefined;
+export declare namespace TsoaRoute {
+    interface Models {
+        [name: string]: ModelSchema;
+    }
+    /**
+     * This is a convenience type so you can check .properties on the items in the Record without having TypeScript throw a compiler error. That's because this Record can't have enums in it. If you want that, then just use the base interface
+     */
+    interface RefObjectModels extends TsoaRoute.Models {
+        [refNames: string]: TsoaRoute.RefObjectModelSchema;
+    }
+    interface RefEnumModelSchema {
+        dataType: 'refEnum';
+        enums: Array<string | number>;
+    }
+    interface RefObjectModelSchema {
+        dataType: 'refObject';
+        properties: {
+            [name: string]: PropertySchema;
+        };
+        additionalProperties?: boolean | PropertySchema;
+    }
+    interface RefTypeAliasModelSchema {
+        dataType: 'refAlias';
+        type: PropertySchema;
+    }
+    type ModelSchema = RefEnumModelSchema | RefObjectModelSchema | RefTypeAliasModelSchema;
+    type ValidatorSchema = Tsoa.Validators;
+    interface PropertySchema {
+        dataType?: Tsoa.TypeStringLiteral;
+        ref?: string;
+        required?: boolean;
+        array?: PropertySchema;
+        enums?: Array<string | number | boolean | null>;
+        type?: PropertySchema;
+        subSchemas?: PropertySchema[];
+        validators?: ValidatorSchema;
+        default?: unknown;
+        additionalProperties?: boolean | PropertySchema;
+        nestedProperties?: {
+            [name: string]: PropertySchema;
+        };
+    }
+    interface ParameterSchema extends PropertySchema {
+        name: string;
+        in: string;
+    }
+    interface Security {
+        [key: string]: string[];
+    }
+}

package/dist/routeGeneration/tsoa-route.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefaultForAdditionalPropertiesAllowed = isDefaultForAdditionalPropertiesAllowed;
+/**
+ * For Swagger, additionalProperties is implicitly allowed. So use this function to clarify that undefined should be associated with allowing additional properties
+ * @param test if this is undefined then you should interpret it as a "yes"
+ */
+function isDefaultForAdditionalPropertiesAllowed(test) {
+    return test === undefined;
+}
+//# sourceMappingURL=tsoa-route.js.map

package/dist/routeGeneration/tsoa-route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsoa-route.js","sourceRoot":"","sources":["../../src/routeGeneration/tsoa-route.ts"],"names":[],"mappings":";;AAMA,0FAEC;AAND;;;GAGG;AACH,SAAgB,uCAAuC,CAAC,IAA4D;IAClH,OAAO,IAAI,KAAK,SAAS,CAAA;AAC3B,CAAC"}

package/dist/swagger/swagger.d.ts

@@ -0,0 +1,550 @@
+export declare namespace Swagger {
+    export type DataType = 'integer' | 'number' | 'boolean' | 'string' | 'array' | 'object' | 'file' | 'undefined';
+    export type DataFormat = 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
+    export type Protocol = 'http' | 'https' | 'ws' | 'wss';
+    export type SupportedSpecMajorVersion = 2 | 3 | 3.1;
+    export interface Spec {
+        info: Info;
+        tags?: Tag[];
+        externalDocs?: ExternalDocs;
+    }
+    export interface Spec2 extends Spec {
+        swagger: '2.0';
+        host?: string;
+        basePath?: string;
+        schemes?: Protocol[];
+        consumes?: string[];
+        produces?: string[];
+        paths: {
+            [name: string]: Path;
+        };
+        definitions?: {
+            [name: string]: Schema2;
+        };
+        parameters?: {
+            [name: string]: Parameter2;
+        };
+        responses?: {
+            [name: string]: Response;
+        };
+        security?: Security[];
+        securityDefinitions?: {
+            [name: string]: SecuritySchemes;
+        };
+    }
+    /**
+     * Base interface for all OpenAPI 3.x specifications
+     * Contains fields shared across all 3.x versions
+     */
+    export interface Spec3x extends Spec {
+        servers: Server[];
+    }
+    /**
+     * OpenAPI 3.0.x specification
+     */
+    export interface Spec30 extends Spec3x {
+        openapi: '3.0.0';
+        components: Components;
+        paths: {
+            [name: string]: Path3;
+        };
+    }
+    /**
+     * OpenAPI 3.1.x specification
+     */
+    export interface Spec31 extends Spec3x {
+        openapi: '3.1.0';
+        components: Components31;
+        paths: {
+            [name: string]: Path31;
+        };
+    }
+    /**
+     * Union type representing any OpenAPI 3.x specification (3.0 or 3.1)
+     * Use Spec30 or Spec31 when you know the specific version
+     */
+    export type Spec3 = Spec30 | Spec31;
+    export interface Path31 {
+        $ref?: string;
+        get?: Operation31;
+        put?: Operation31;
+        post?: Operation31;
+        delete?: Operation31;
+        options?: Operation31;
+        head?: Operation31;
+        patch?: Operation31;
+        parameters?: Parameter31[];
+    }
+    export interface Components {
+        callbacks?: {
+            [name: string]: unknown;
+        };
+        examples?: {
+            [name: string]: Example3 | string;
+        };
+        headers?: {
+            [name: string]: unknown;
+        };
+        links?: {
+            [name: string]: unknown;
+        };
+        parameters?: {
+            [name: string]: Parameter3;
+        };
+        requestBodies?: {
+            [name: string]: unknown;
+        };
+        responses?: {
+            [name: string]: Response;
+        };
+        schemas?: {
+            [name: string]: Schema3;
+        };
+        securitySchemes?: {
+            [name: string]: SecuritySchemes;
+        };
+    }
+    export interface Components31 extends Omit<Components, 'schemas'> {
+        schemas?: {
+            [name: string]: Schema31;
+        };
+    }
+    export interface Server {
+        url: string;
+    }
+    export interface Info {
+        title: string;
+        version?: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: Contact;
+        license?: License;
+    }
+    export interface Contact {
+        name?: string;
+        email?: string;
+        url?: string;
+    }
+    export interface License {
+        name: string;
+        url?: string;
+    }
+    export interface ExternalDocs {
+        url: string;
+        description?: string;
+    }
+    export interface Tag {
+        name: string;
+        description?: string;
+        externalDocs?: ExternalDocs;
+    }
+    export interface Example3 {
+        value: unknown;
+        summary?: string;
+        description?: string;
+    }
+    export type BaseParameter = {
+        name: string;
+        in: 'query' | 'header' | 'path' | 'formData' | 'body' | 'cookie';
+        required?: boolean;
+        description?: string;
+        deprecated?: boolean;
+        [ext: `x-${string}`]: unknown;
+    } & Pick<BaseSchema, 'type' | 'items' | 'enum' | 'format' | 'minimum' | 'maximum' | 'minLength' | 'maxLength' | 'pattern'>;
+    export type BodyParameter = BaseParameter & {
+        in: 'body';
+    };
+    export type FormDataParameter = BaseParameter & {
+        in: 'formData';
+        type: DataType;
+        format?: DataFormat;
+        collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
+        default?: unknown;
+    };
+    type QueryParameter = BaseParameter & {
+        in: 'query';
+        type: DataType;
+        format?: DataFormat;
+        collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
+        default?: unknown;
+    };
+    type PathParameter = BaseParameter & {
+        in: 'path';
+        type: DataType;
+        format?: DataFormat;
+        default?: unknown;
+    };
+    type HeaderParameter = BaseParameter & {
+        in: 'header';
+        type: DataType;
+        format?: DataFormat;
+        default?: unknown;
+    };
+    type Swagger2BaseParameter = BaseParameter & {
+        schema: Schema2;
+    };
+    export type Swagger2BodyParameter = Swagger2BaseParameter & BodyParameter;
+    export type Swagger2FormDataParameter = Swagger2BaseParameter & FormDataParameter;
+    export type Swagger2QueryParameter = Swagger2BaseParameter & QueryParameter;
+    export type Swagger2PathParameter = Swagger2BaseParameter & PathParameter;
+    export type Swagger2HeaderParameter = Swagger2BaseParameter & HeaderParameter;
+    export type Parameter2 = Swagger2BodyParameter | Swagger2FormDataParameter | Swagger2QueryParameter | Swagger2PathParameter | Swagger2HeaderParameter;
+    export function isQueryParameter(parameter: unknown): parameter is Swagger2QueryParameter;
+    export interface Parameter3 extends BaseParameter {
+        in: 'query' | 'header' | 'path' | 'cookie';
+        schema: Schema3;
+        style?: string;
+        explode?: boolean;
+        allowReserved?: boolean;
+        example?: unknown;
+        examples?: {
+            [name: string]: Example3 | string;
+        };
+    }
+    export interface Parameter31 extends Omit<Parameter3, 'schema'> {
+        schema: Schema31;
+    }
+    export interface Path {
+        $ref?: string;
+        get?: Operation;
+        put?: Operation;
+        post?: Operation;
+        delete?: Operation;
+        options?: Operation;
+        head?: Operation;
+        patch?: Operation;
+        parameters?: Parameter2[];
+    }
+    export interface Path3 {
+        $ref?: string;
+        get?: Operation3;
+        put?: Operation3;
+        post?: Operation3;
+        delete?: Operation3;
+        options?: Operation3;
+        head?: Operation3;
+        patch?: Operation3;
+        parameters?: Parameter3[];
+    }
+    export interface Operation {
+        tags?: string[];
+        summary?: string;
+        description?: string;
+        externalDocs?: ExternalDocs;
+        operationId: string;
+        consumes?: string[];
+        produces?: string[];
+        parameters?: Parameter2[];
+        responses: {
+            [name: string]: Response;
+        };
+        schemes?: Protocol[];
+        deprecated?: boolean;
+        security?: Security[];
+        [key: string]: unknown;
+    }
+    export interface Operation3 {
+        tags?: string[];
+        summary?: string;
+        description?: string;
+        externalDocs?: ExternalDocs;
+        operationId: string;
+        consumes?: string[];
+        parameters?: Parameter3[];
+        responses: {
+            [name: string]: Response3;
+        };
+        schemes?: Protocol[];
+        deprecated?: boolean;
+        security?: Security[];
+        requestBody?: RequestBody;
+        [ext: `x-${string}`]: unknown;
+    }
+    export interface Operation31 extends Omit<Operation3, 'responses' | 'requestBody' | 'parameters'> {
+        parameters?: Parameter31[];
+        requestBody?: RequestBody31;
+        responses: {
+            [name: string]: Response31;
+        };
+    }
+    export interface RequestBody {
+        content: {
+            [requestMediaType: string]: MediaType;
+        };
+        description?: string;
+        required?: boolean;
+    }
+    export interface RequestBody31 {
+        content: {
+            [requestMediaType: string]: MediaType31;
+        };
+        description?: string;
+        required?: boolean;
+        $ref?: string;
+        summary?: string;
+        examples?: {
+            [media: string]: Example3 | string;
+        };
+        [ext: `x-${string}`]: unknown;
+    }
+    export interface MediaType {
+        schema?: Schema3;
+        example?: unknown;
+        examples?: {
+            [name: string]: Example3 | string;
+        };
+        encoding?: {
+            [name: string]: unknown;
+        };
+    }
+    export interface MediaType31 {
+        schema?: Schema31;
+        example?: unknown;
+        examples?: {
+            [name: string]: Example3 | string;
+        };
+        encoding?: {
+            [name: string]: unknown;
+        };
+    }
+    export interface Response {
+        description: string;
+        schema?: BaseSchema;
+        headers?: {
+            [name: string]: Header;
+        };
+        examples?: {
+            [responseMediaType: string]: {
+                [exampleName: string]: Example3 | string;
+            };
+        };
+    }
+    export interface Response3 {
+        description: string;
+        content?: {
+            [responseMediaType: string]: {
+                schema: Schema3;
+                examples?: {
+                    [name: string]: Example3 | string;
+                };
+            };
+        };
+        headers?: {
+            [name: string]: Header3;
+        };
+    }
+    export interface Response31 {
+        description: string;
+        content?: {
+            [responseMediaType: string]: {
+                schema?: Schema31;
+                examples?: {
+                    [name: string]: Example3 | string;
+                };
+                example?: unknown;
+                encoding?: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+        headers?: {
+            [name: string]: Header3;
+        };
+        links?: {
+            [name: string]: unknown;
+        };
+    }
+    export interface BaseSchema<P = unknown> {
+        type?: string;
+        format?: DataFormat;
+        $ref?: string;
+        title?: string;
+        description?: string;
+        default?: string | boolean | number | unknown;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        enum?: Array<boolean | string | number | null>;
+        'x-enum-varnames'?: string[];
+        [ext: `x-${string}`]: unknown;
+        additionalProperties?: boolean | BaseSchema;
+        properties?: {
+            [propertyName: string]: P;
+        };
+        discriminator?: string;
+        readOnly?: boolean;
+        xml?: XML;
+        externalDocs?: ExternalDocs;
+        example?: unknown;
+        required?: string[];
+        items?: BaseSchema;
+    }
+    export interface Schema31 extends Omit<Schema3, 'items' | 'properties' | 'additionalProperties' | 'discriminator' | 'anyOf' | 'allOf'> {
+        examples?: unknown[];
+        properties?: {
+            [key: string]: Schema31;
+        };
+        additionalProperties?: boolean | Schema31;
+        items?: Schema31 | false;
+        prefixItems?: Schema31[];
+        contains?: Schema31;
+        allOf?: Schema31[];
+        anyOf?: Schema31[];
+        oneOf?: Schema31[];
+        not?: Schema31;
+        propertyNames?: Schema31;
+        discriminator?: {
+            propertyName: string;
+            mapping?: Record<string, string>;
+        };
+    }
+    export interface Schema3 extends Omit<BaseSchema, 'type'> {
+        type?: DataType;
+        nullable?: boolean;
+        anyOf?: BaseSchema[];
+        allOf?: BaseSchema[];
+        deprecated?: boolean;
+        properties?: {
+            [propertyName: string]: Schema3;
+        };
+    }
+    export interface Schema2 extends BaseSchema {
+        type?: DataType;
+        properties?: {
+            [propertyName: string]: Schema2;
+        };
+        ['x-nullable']?: boolean;
+        ['x-deprecated']?: boolean;
+    }
+    export interface Header {
+        description?: string;
+        type: 'string' | 'number' | 'integer' | 'boolean' | 'array';
+        format?: string;
+        items?: BaseSchema;
+        collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
+        default?: string | boolean | number | unknown;
+        maximum?: number;
+        exclusiveMaximum?: boolean;
+        minimum?: number;
+        exclusiveMinimum?: boolean;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        enum?: Array<string | number | null>;
+        multipleOf?: number;
+    }
+    export interface Header3 {
+        description?: string;
+        required?: boolean;
+        deprecated?: boolean;
+        allowEmptyValue?: boolean;
+        style?: string;
+        explode?: boolean;
+        allowReserved?: boolean;
+        schema?: Schema3 | Schema31;
+        example?: unknown;
+        examples?: {
+            [media: string]: Example3 | string;
+        };
+        content?: {
+            [media: string]: {
+                schema?: Schema3 | Schema31;
+                example?: unknown;
+                examples?: {
+                    [name: string]: Example3 | string;
+                };
+            };
+        };
+        [ext: `x-${string}`]: unknown;
+    }
+    export interface XML {
+        type?: string;
+        namespace?: string;
+        prefix?: string;
+        attribute?: string;
+        wrapped?: boolean;
+    }
+    interface BaseSecurity {
+        description?: string;
+    }
+    export interface ApiKeySecurity extends BaseSecurity {
+        type: 'apiKey';
+        name: string;
+        in: 'query' | 'header';
+    }
+    interface BaseOAuthSecurity extends BaseSecurity {
+        scopes?: OAuthScope;
+    }
+    export interface BasicSecurity3 extends BaseSecurity {
+        type: 'http';
+        scheme: 'basic';
+    }
+    export interface BasicSecurity extends BaseSecurity {
+        type: 'basic';
+    }
+    export interface BearerSecurity3 extends BaseSecurity {
+        type: 'http';
+        scheme: 'bearer';
+        bearerFormat?: string;
+    }
+    export interface OpenIDSecurity extends BaseSecurity {
+        type: 'openIdConnect';
+        openIdConnectUrl: string;
+    }
+    export interface OAuth2Security3 extends BaseSecurity {
+        type: 'oauth2';
+        flows: OAuthFlow;
+    }
+    export interface OAuth2SecurityFlow3 extends BaseSecurity {
+        tokenUrl?: string;
+        authorizationUrl?: string;
+        scopes?: OAuthScope;
+    }
+    export interface OAuth2ImplicitSecurity extends BaseOAuthSecurity {
+        type: 'oauth2';
+        description?: string;
+        flow: 'implicit';
+        authorizationUrl: string;
+    }
+    export interface OAuth2PasswordSecurity extends BaseOAuthSecurity {
+        type: 'oauth2';
+        flow: 'password';
+        tokenUrl: string;
+    }
+    export interface OAuth2ApplicationSecurity extends BaseOAuthSecurity {
+        type: 'oauth2';
+        flow: 'application';
+        tokenUrl: string;
+    }
+    export interface OAuth2AccessCodeSecurity extends BaseOAuthSecurity {
+        type: 'oauth2';
+        flow: 'accessCode';
+        tokenUrl: string;
+        authorizationUrl: string;
+    }
+    export interface OAuthScope {
+        [scopeName: string]: string;
+    }
+    export type OAuthFlow = {
+        [flowName in OAuth2FlowTypes]?: OAuth2SecurityFlow3;
+    };
+    export type OAuth2FlowTypes = 'authorizationCode' | 'implicit' | 'password' | 'clientCredentials';
+    export type SecuritySchemes = ApiKeySecurity | BasicSecurity | BasicSecurity3 | BearerSecurity3 | OpenIDSecurity | OAuth2AccessCodeSecurity | OAuth2ApplicationSecurity | OAuth2ImplicitSecurity | OAuth2PasswordSecurity | OAuth2Security3;
+    export interface Security {
+        [key: string]: string[];
+    }
+    export {};
+}

package/dist/swagger/swagger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Swagger = void 0;
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var Swagger;
+(function (Swagger) {
+    function isQueryParameter(parameter) {
+        return typeof parameter === 'object' && parameter !== null && 'in' in parameter && parameter.in === 'query';
+    }
+    Swagger.isQueryParameter = isQueryParameter;
+})(Swagger || (exports.Swagger = Swagger = {}));
+//# sourceMappingURL=swagger.js.map

package/dist/swagger/swagger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swagger.js","sourceRoot":"","sources":["../../src/swagger/swagger.ts"],"names":[],"mappings":";;;AAAA,2DAA2D;AAC3D,IAAiB,OAAO,CA2iBvB;AA3iBD,WAAiB,OAAO;IA0LtB,SAAgB,gBAAgB,CAAC,SAAkB;QACjD,OAAO,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,IAAI,IAAI,IAAI,IAAI,SAAS,IAAI,SAAS,CAAC,EAAE,KAAK,OAAO,CAAA;IAC7G,CAAC;IAFe,wBAAgB,mBAE/B,CAAA;AA+WH,CAAC,EA3iBgB,OAAO,uBAAP,OAAO,QA2iBvB"}

package/dist/utils/assertNever.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This function does exhaustiveness checking to ensure that you have discriminated a union so that no type remains. Use this to get the typescript compiler to help discover cases that were not considered.
+ */
+export declare function assertNever(value: never): never;

package/dist/utils/assertNever.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNever = assertNever;
+/**
+ * This function does exhaustiveness checking to ensure that you have discriminated a union so that no type remains. Use this to get the typescript compiler to help discover cases that were not considered.
+ */
+function assertNever(value) {
+    throw new Error(`Unhandled discriminated union member: ${JSON.stringify(value)}`);
+}
+//# sourceMappingURL=assertNever.js.map