@skmtc/core 0.0.961 → 0.0.963

package/esm/oas/ref/Ref.js

@@ -11,8 +11,32 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _OasRef_fields, _OasRef_oasDocument;
 import { toRefName } from '../../helpers/refFns.js';
-import { match } from 'ts-pattern';
 const MAX_LOOKUPS = 10;
+/**
+ * Converts a ref type to its plural components path.
+ */
+function refTypeToPluralPath(refType) {
+    switch (refType) {
+        case 'schema':
+            return 'schemas';
+        case 'requestBody':
+            return 'requestBodies';
+        case 'parameter':
+            return 'parameters';
+        case 'response':
+            return 'responses';
+        case 'example':
+            return 'examples';
+        case 'header':
+            return 'headers';
+        case 'securityScheme':
+            return 'securitySchemes';
+        default: {
+            const _exhaustive = refType;
+            throw new Error(`Unhandled ref type: ${_exhaustive}`);
+        }
+    }
+}
 /**
  * Represents an OpenAPI reference ($ref) in the SKMTC OAS processing system.
  *
@@ -160,15 +184,34 @@ export class OasRef {
         const c = this.oasDocument.components;
         const refName = toRefName(this.$ref);
         const refType = this.refType;
-        const resolved = match(refType)
-            .with('schema', () => c?.schemas?.[refName])
-            .with('requestBody', () => c?.requestBodies?.[refName])
-            .with('parameter', () => c?.parameters?.[refName])
-            .with('response', () => c?.responses?.[refName])
-            .with('example', () => c?.examples?.[refName])
-            .with('header', () => c?.headers?.[refName])
-            .with('securityScheme', () => c?.securitySchemes?.[refName])
-            .exhaustive();
+        let resolved;
+        switch (refType) {
+            case 'schema':
+                resolved = c?.schemas?.[refName];
+                break;
+            case 'requestBody':
+                resolved = c?.requestBodies?.[refName];
+                break;
+            case 'parameter':
+                resolved = c?.parameters?.[refName];
+                break;
+            case 'response':
+                resolved = c?.responses?.[refName];
+                break;
+            case 'example':
+                resolved = c?.examples?.[refName];
+                break;
+            case 'header':
+                resolved = c?.headers?.[refName];
+                break;
+            case 'securityScheme':
+                resolved = c?.securitySchemes?.[refName];
+                break;
+            default: {
+                const _exhaustive = refType;
+                throw new Error(`Unhandled ref type: ${_exhaustive}`);
+            }
+        }
         if (!resolved) {
             throw new Error(`Ref "${__classPrivateFieldGet(this, _OasRef_fields, "f").$ref}" not found`);
         }
@@ -202,29 +245,13 @@ export class OasRef {
             return resolved;
         }
         const ref = {
-            $ref: `#/components/${match(this.refType)
-                .with('schema', () => 'schemas')
-                .with('requestBody', () => 'requestBodies')
-                .with('parameter', () => 'parameters')
-                .with('response', () => 'responses')
-                .with('example', () => 'examples')
-                .with('header', () => 'headers')
-                .with('securityScheme', () => 'securitySchemes')
-                .exhaustive()}/${this.toRefName()}`
+            $ref: `#/components/${refTypeToPluralPath(this.refType)}/${this.toRefName()}`
         };
         return ref;
     }
     toJSON() {
         return {
-            $ref: `#/components/${match(this.refType)
-                .with('schema', () => 'schemas')
-                .with('requestBody', () => 'requestBodies')
-                .with('parameter', () => 'parameters')
-                .with('response', () => 'responses')
-                .with('example', () => 'examples')
-                .with('header', () => 'headers')
-                .with('securityScheme', () => 'securitySchemes')
-                .exhaustive()}/${this.toRefName()}`
+            $ref: `#/components/${refTypeToPluralPath(this.refType)}/${this.toRefName()}`
         };
     }
 }

package/esm/oas/schema/toSchemasV3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toSchemasV3.d.ts","sourceRoot":"","sources":["../../../src/oas/schema/toSchemasV3.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAa3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,KAAK,eAAe,GAAG;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,CAAA;IAC3E,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,kCAIzB,eAAe,KAAG,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAsB/D,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,GAAG,SAAS,CAAA;IACvF,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,kCAIjC,uBAAuB,KAAG,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,SAM3E,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAA;IAC1D,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,iCAIxB,cAAc,KAAG,SAAS,GAAG,MAAM,CAAC,QAAQ,CAiK9C,CAAA;AA+CD,KAAK,sBAAsB,GAAG;IAC5B,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,GAAG,SAAS,CAAA;IACtE,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,iCAIhC,sBAAsB,KAAG,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAM1D,CAAA"}
+{"version":3,"file":"toSchemasV3.d.ts","sourceRoot":"","sources":["../../../src/oas/schema/toSchemasV3.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAa3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,KAAK,eAAe,GAAG;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,CAAA;IAC3E,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,kCAIzB,eAAe,KAAG,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAsB/D,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,GAAG,SAAS,CAAA;IACvF,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,kCAIjC,uBAAuB,KAAG,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,SAM3E,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAA;IAC1D,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,iCAIxB,cAAc,KAAG,SAAS,GAAG,MAAM,CAAC,QAAQ,CA6K9C,CAAA;AA+CD,KAAK,sBAAsB,GAAG;IAC5B,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,GAAG,SAAS,CAAA;IACtE,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,iCAIhC,sBAAsB,KAAG,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAM1D,CAAA"}

package/esm/oas/schema/toSchemasV3.js

@@ -1,6 +1,5 @@
 import { toRefV31 } from '../ref/toRefV31.js';
 import { isRef } from '../../helpers/refFns.js';
-import { match, P } from 'ts-pattern';
 import { toArray } from '../array/toArray.js';
 import { toObject } from '../object/toObject.js';
 import { toInteger } from '../integer/toInteger.js';
@@ -44,8 +43,7 @@ export const toSchemaV3 = ({ schema, stackTrail, context }) => {
     if (isRef(schema)) {
         return toRefV31({ ref: schema, refType: 'schema', stackTrail, context });
     }
-    return match(schema)
-        .with({ allOf: P.array() }, schema => {
+    if ('allOf' in schema && Array.isArray(schema.allOf)) {
         return stackTrail.trace('allOf', st => {
             const merged = mergeIntersection({
                 schema,
@@ -53,11 +51,11 @@ export const toSchemaV3 = ({ schema, stackTrail, context }) => {
             });
             return toSchemaV3({ schema: merged, stackTrail: st, context });
         });
-    })
-        .with({ oneOf: P.array() }, oneOf => {
+    }
+    if ('oneOf' in schema && Array.isArray(schema.oneOf)) {
         return stackTrail.trace('oneOf', st => {
             const merged = mergeUnion({
-                schema: oneOf,
+                schema,
                 getRef: toGetRef(context.documentObject),
                 groupType: 'oneOf'
             });
@@ -73,17 +71,17 @@ export const toSchemaV3 = ({ schema, stackTrail, context }) => {
             }
             return toUnion({ value, members, parentType: 'oneOf', stackTrail: st, context });
         });
-    })
-        .with({ anyOf: P.array() }, matched => {
+    }
+    if ('anyOf' in schema && Array.isArray(schema.anyOf)) {
         return stackTrail.trace('anyOf', st => {
             // deno-lint-ignore ban-ts-comment
             // @ts-expect-error
-            if (matched['x-expansionResources']) {
-                const { anyOf, ...value } = matched;
+            if (schema['x-expansionResources'] && Array.isArray(schema.anyOf)) {
+                const { anyOf, ...value } = schema;
                 return toUnion({ value, members: anyOf, parentType: 'anyOf', stackTrail: st, context });
             }
             const merged = mergeUnion({
-                schema: matched,
+                schema,
                 getRef: toGetRef(context.documentObject),
                 groupType: 'anyOf'
             });
@@ -99,85 +97,94 @@ export const toSchemaV3 = ({ schema, stackTrail, context }) => {
             }
             return toUnion({ value, members, parentType: 'anyOf', stackTrail: st, context });
         });
-    })
-        .with({ type: 'object' }, value => toObject({ value, stackTrail, context }))
-        .with({ type: 'array' }, value => toArray({ value, stackTrail, context }))
-        .with({ type: 'integer' }, value => toInteger({ value, stackTrail, context }))
-        .with({ type: 'number' }, value => toNumber({ value, stackTrail, context }))
-        .with({ type: 'boolean' }, value => toBoolean({ value, stackTrail, context }))
-        .with({ type: 'string' }, value => toString({ value, stackTrail, context }))
-        .otherwise(value => {
-        if (possibleObject(value)) {
-            context.logIssueNoKey({
-                level: 'warning',
-                message: 'Object has "properties" property, but is missing type="object" property',
-                parent: value,
-                stackTrail,
-                type: 'MISSING_OBJECT_TYPE'
-            });
-            return toObject({
-                value: {
-                    ...value,
-                    type: 'object'
-                },
-                stackTrail,
-                context
-            });
-        }
-        if (possibleArray(value)) {
-            context.logIssueNoKey({
-                level: 'warning',
-                message: 'Object has "items" property, but is missing type="array" property',
-                parent: value,
-                stackTrail,
-                type: 'MISSING_ARRAY_TYPE'
-            });
-            return toArray({
-                value: {
-                    ...value,
-                    type: 'array'
-                    // Adding cast here since {} is a valid value for items
-                },
-                stackTrail,
-                context
-            });
-        }
-        if (possibleBoolean(value)) {
-            context.logIssueNoKey({
-                level: 'warning',
-                message: 'Object has a boolean "default" or "example" property, but is missing type="boolean" property',
-                parent: value,
-                stackTrail,
-                type: 'MISSING_BOOLEAN_TYPE'
-            });
-            return toBoolean({
-                value: {
-                    ...value,
-                    type: 'boolean'
-                },
-                stackTrail,
-                context
-            });
-        }
-        if (possibleString(value)) {
-            context.logIssueNoKey({
-                level: 'warning',
-                message: 'Object has a string "default" or "example" property, but is missing type="string" property',
-                parent: value,
-                stackTrail,
-                type: 'MISSING_STRING_TYPE'
-            });
-            return toString({
-                value: {
-                    ...value,
-                    type: 'string'
-                },
-                stackTrail,
-                context
-            });
+    }
+    if ('type' in schema) {
+        switch (schema.type) {
+            case 'object':
+                return toObject({ value: schema, stackTrail, context });
+            case 'array':
+                return toArray({ value: schema, stackTrail, context });
+            case 'integer':
+                return toInteger({ value: schema, stackTrail, context });
+            case 'number':
+                return toNumber({ value: schema, stackTrail, context });
+            case 'boolean':
+                return toBoolean({ value: schema, stackTrail, context });
+            case 'string':
+                return toString({ value: schema, stackTrail, context });
         }
-        return toUnknown({ value, stackTrail, context });
-    });
+    }
+    // Otherwise cases
+    if (possibleObject(schema)) {
+        context.logIssueNoKey({
+            level: 'warning',
+            message: 'Object has "properties" property, but is missing type="object" property',
+            parent: schema,
+            stackTrail,
+            type: 'MISSING_OBJECT_TYPE'
+        });
+        return toObject({
+            value: {
+                ...schema,
+                type: 'object'
+            },
+            stackTrail,
+            context
+        });
+    }
+    if (possibleArray(schema)) {
+        context.logIssueNoKey({
+            level: 'warning',
+            message: 'Object has "items" property, but is missing type="array" property',
+            parent: schema,
+            stackTrail,
+            type: 'MISSING_ARRAY_TYPE'
+        });
+        return toArray({
+            value: {
+                ...schema,
+                type: 'array'
+                // Adding cast here since {} is a valid value for items
+            },
+            stackTrail,
+            context
+        });
+    }
+    if (possibleBoolean(schema)) {
+        context.logIssueNoKey({
+            level: 'warning',
+            message: 'Object has a boolean "default" or "example" property, but is missing type="boolean" property',
+            parent: schema,
+            stackTrail,
+            type: 'MISSING_BOOLEAN_TYPE'
+        });
+        return toBoolean({
+            value: {
+                ...schema,
+                type: 'boolean'
+            },
+            stackTrail,
+            context
+        });
+    }
+    if (possibleString(schema)) {
+        context.logIssueNoKey({
+            level: 'warning',
+            message: 'Object has a string "default" or "example" property, but is missing type="string" property',
+            parent: schema,
+            stackTrail,
+            type: 'MISSING_STRING_TYPE'
+        });
+        return toString({
+            value: {
+                ...schema,
+                type: 'string'
+            },
+            stackTrail,
+            context
+        });
+    }
+    return toUnknown({ value: schema, stackTrail, context });
 };
 const possibleString = (value) => {
     return (value &&

package/esm/oas/securitySchemes/toSecuritySchemes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toSecuritySchemes.d.ts","sourceRoot":"","sources":["../../../src/oas/securitySchemes/toSecuritySchemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAgBnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAK5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,KAAK,qBAAqB,GAAG;IAC3B,eAAe,EACX,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,oBAAoB,CAAC,GAC1E,SAAS,CAAA;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,0CAIjC,qBAAqB,KACxB,AAD2B,iDAAiD;AAC5E,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAenC,CAAA"}
+{"version":3,"file":"toSecuritySchemes.d.ts","sourceRoot":"","sources":["../../../src/oas/securitySchemes/toSecuritySchemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAenE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAK5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,KAAK,qBAAqB,GAAG;IAC3B,eAAe,EACX,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,oBAAoB,CAAC,GAC1E,SAAS,CAAA;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,0CAIjC,qBAAqB,KACxB,AAD2B,iDAAiD;AAC5E,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAenC,CAAA"}

package/esm/oas/securitySchemes/toSecuritySchemes.js

@@ -1,4 +1,3 @@
-import { match } from 'ts-pattern';
 import { OasHttpSecurityScheme, OasApiKeySecurityScheme, OasOAuth2SecurityScheme, OasOpenIdSecurityScheme } from './SecurityScheme.js';
 import * as v from 'valibot';
 import { oasApiKeySecuritySchemeData, oasHttpSecuritySchemeData, oasOAuth2SecuritySchemeData, oasOpenIdSecuritySchemeData } from './security-scheme-types.js';
@@ -20,71 +19,71 @@ const toSecuritySchemeV3 = ({ securityScheme, stackTrail, context }) => {
     if (isRef(securityScheme)) {
         return toRefV31({ ref: securityScheme, refType: 'securityScheme', stackTrail, context });
     }
-    return match(securityScheme)
-        .with({ type: 'http' }, matched => {
-        const { type: _type, description, scheme, bearerFormat, ...skipped } = v.parse(oasHttpSecuritySchemeData, matched);
-        if (!isEmpty(skipped)) {
-            context.logSkippedFields({
-                skipped,
-                parent: matched,
-                stackTrail,
-                parentType: 'securityScheme:http'
+    switch (securityScheme.type) {
+        case 'http': {
+            const { type: _type, description, scheme, bearerFormat, ...skipped } = v.parse(oasHttpSecuritySchemeData, securityScheme);
+            if (!isEmpty(skipped)) {
+                context.logSkippedFields({
+                    skipped,
+                    parent: securityScheme,
+                    stackTrail,
+                    parentType: 'securityScheme:http'
+                });
+            }
+            return new OasHttpSecurityScheme({
+                description,
+                scheme,
+                bearerFormat
             });
         }
-        return new OasHttpSecurityScheme({
-            description,
-            scheme,
-            bearerFormat
-        });
-    })
-        .with({ type: 'apiKey' }, matched => {
-        const { type: _type, in: location, description, name, ...skipped } = v.parse(oasApiKeySecuritySchemeData, matched);
-        if (!isEmpty(skipped)) {
-            context.logSkippedFields({
-                skipped,
-                parent: matched,
-                stackTrail,
-                parentType: 'securityScheme:apiKey'
+        case 'apiKey': {
+            const { type: _type, in: location, description, name, ...skipped } = v.parse(oasApiKeySecuritySchemeData, securityScheme);
+            if (!isEmpty(skipped)) {
+                context.logSkippedFields({
+                    skipped,
+                    parent: securityScheme,
+                    stackTrail,
+                    parentType: 'securityScheme:apiKey'
+                });
+            }
+            return new OasApiKeySecurityScheme({
+                description,
+                name,
+                in: location
             });
         }
-        return new OasApiKeySecurityScheme({
-            description,
-            name,
-            in: location
-        });
-    })
-        .with({ type: 'oauth2' }, matched => {
-        const { type: _type, flows, description, ...skipped } = v.parse(oasOAuth2SecuritySchemeData, matched);
-        if (!isEmpty(skipped)) {
-            context.logSkippedFields({
-                skipped,
-                parent: matched,
-                stackTrail,
-                parentType: 'securityScheme:oauth2'
+        case 'oauth2': {
+            const { type: _type, flows, description, ...skipped } = v.parse(oasOAuth2SecuritySchemeData, securityScheme);
+            if (!isEmpty(skipped)) {
+                context.logSkippedFields({
+                    skipped,
+                    parent: securityScheme,
+                    stackTrail,
+                    parentType: 'securityScheme:oauth2'
+                });
+            }
+            return new OasOAuth2SecurityScheme({
+                description,
+                flows
             });
         }
-        return new OasOAuth2SecurityScheme({
-            description,
-            flows
-        });
-    })
-        .with({ type: 'openIdConnect' }, matched => {
-        const { type: _type, description, openIdConnectUrl, ...skipped } = v.parse(oasOpenIdSecuritySchemeData, matched);
-        if (!isEmpty(skipped)) {
-            context.logSkippedFields({
-                skipped,
-                parent: matched,
-                stackTrail,
-                parentType: 'securityScheme:openIdConnect'
+        case 'openIdConnect': {
+            const { type: _type, description, openIdConnectUrl, ...skipped } = v.parse(oasOpenIdSecuritySchemeData, securityScheme);
+            if (!isEmpty(skipped)) {
+                context.logSkippedFields({
+                    skipped,
+                    parent: securityScheme,
+                    stackTrail,
+                    parentType: 'securityScheme:openIdConnect'
+                });
+            }
+            return new OasOpenIdSecurityScheme({
+                description,
+                openIdConnectUrl
             });
         }
-        return new OasOpenIdSecurityScheme({
-            description,
-            openIdConnectUrl
-        });
-    })
-        .otherwise(other => {
-        // TODO: skip ref
-        throw new Error(`Unknown security scheme type: ${other}`);
-    });
+        default:
+            // TODO: skip ref
+            throw new Error(`Unknown security scheme type: ${securityScheme.type}`);
+    }
 };

package/esm/typescript/FunctionParameter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionParameter.d.ts","sourceRoot":"","sources":["../../src/typescript/FunctionParameter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,IAAI,EAAwB,MAAM,WAAW,CAAA;AAItD;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B,+FAA+F;IAC/F,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,4CAA4C;IAC5C,cAAc,EAAE,UAAU,CAAC,gBAAgB,GAAG,cAAc,CAAC,CAAA;IAC7D,mDAAmD;IACnD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,kEAAkE;IAClE,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG,qBAAqB,GAAG,gBAAgB,CAAA;AAE1F;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,cAAc,CAAA;IACpB,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAA;IAC5C,QAAQ,EAAE,IAAI,CAAA;CACf,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,cAAc,EAAE,UAAU,CAAC,eAAe,CAAC,CAAA;IAC3C,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkJG;AACH,qBAAa,iBAAiB;IAC5B,sFAAsF;IACtF,UAAU,EAAE,mBAAmB,CAAA;IAE/B,kEAAkE;IAClE,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,IAAI,EAAE,qBAAqB;IA2BvC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAalC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,cAAc,IAAI,IAAI;IAUtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,SAAS,IAAI,MAAM;IAUnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,QAAQ,IAAI,MAAM;CAoBnB"}
+{"version":3,"file":"FunctionParameter.d.ts","sourceRoot":"","sources":["../../src/typescript/FunctionParameter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,IAAI,EAAwB,MAAM,WAAW,CAAA;AAItD;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B,+FAA+F;IAC/F,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,4CAA4C;IAC5C,cAAc,EAAE,UAAU,CAAC,gBAAgB,GAAG,cAAc,CAAC,CAAA;IAC7D,mDAAmD;IACnD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,kEAAkE;IAClE,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG,qBAAqB,GAAG,gBAAgB,CAAA;AAE1F;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,cAAc,CAAA;IACpB,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAA;IAC5C,QAAQ,EAAE,IAAI,CAAA;CACf,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,cAAc,EAAE,UAAU,CAAC,eAAe,CAAC,CAAA;IAC3C,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkJG;AACH,qBAAa,iBAAiB;IAC5B,sFAAsF;IACtF,UAAU,EAAE,mBAAmB,CAAA;IAE/B,kEAAkE;IAClE,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,IAAI,EAAE,qBAAqB;IAyBvC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAuBlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,cAAc,IAAI,IAAI;IAsBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,SAAS,IAAI,MAAM;IAsBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,QAAQ,IAAI,MAAM;CA8BnB"}