@skmtc/core 0.0.984 → 0.16.2

package/esm/parse/v3-0/schema/toSchemasV3.js

@@ -0,0 +1,296 @@
+import { toRefV31 } from '../ref/toRefV31.js';
+import { isRef } from '../../../helpers/refFns.js';
+import { toArray } from '../array/toArray.js';
+import { toObject } from '../object/toObject.js';
+import { toInteger } from '../integer/toInteger.js';
+import { toNumber } from '../number/toNumber.js';
+import { toBoolean } from '../boolean/toBoolean.js';
+import { toString } from '../string/toString.js';
+import { toUnknown } from '../unknown/toUnknown.js';
+import { toUnion } from '../union/toUnion.js';
+import { toGetRef } from '../../../helpers/refFns.js';
+import { mergeIntersection } from '../_merge-all-of/merge-intersection.js';
+import { mergeUnion } from '../_merge-all-of/merge-union.js';
+import { tryParseAt } from '../../../context/tryParseAt.js';
+export const toSchemasV3 = ({ schemas, stackTrail, context }) => {
+    const output = {};
+    const entries = Object.entries(schemas);
+    for (const [key, schema] of entries) {
+        const value = tryParseAt({
+            stackTrail,
+            key,
+            context,
+            type: 'INVALID_SCHEMA',
+            parent: schema,
+            fn: st => toSchemaV3({ schema, stackTrail: st, context })
+        });
+        if (value !== undefined) {
+            output[key] = value;
+        }
+    }
+    return output;
+};
+export const toOptionalSchemasV3 = ({ schemas, stackTrail, context }) => {
+    if (!schemas) {
+        return undefined;
+    }
+    return toSchemasV3({ schemas, stackTrail, context });
+};
+/**
+ * Collapse a single-member `oneOf`/`anyOf` into its surviving member.
+ *
+ * The wrapper's sibling keywords must ride into the member rather than
+ * being discarded. The critical one is `nullable`: down-convert's
+ * `convertNullableOneOfAnyOf` rewrites the 3.1 idiom
+ * `oneOf:[{type:'string'},{type:'null'}]` ("string or null") into
+ * `oneOf:[{type:'string'}]` + a hoisted `nullable:true` on the wrapper.
+ * The old short-circuit re-dispatched `members[0]` alone, dropping the
+ * wrapper (`...value`) and silently turning `string | null` back into a
+ * non-nullable `string`. `description`/`title`/`readOnly`/... ride along
+ * the same way.
+ *
+ * Precedence: the member is the more specific schema, so it wins direct
+ * conflicts (`{ ...value, ...member }`). `nullable` is the exception — it
+ * OR-ins, because a nullable wrapper makes the whole schema nullable even
+ * when the member itself is not.
+ *
+ * A ref member only reaches here when the wrapper carries no `nullable`
+ * (the nullable-ref case stamps `nullable` on the OasRef node at the call
+ * site, via `toRefV31`). Any other wrapper siblings on a bare `$ref` are
+ * ignored per 3.0 ref semantics, so the ref is returned untouched.
+ */
+const collapseSingleMember = (value, member) => {
+    if (isRef(member)) {
+        return member;
+    }
+    const merged = { ...value, ...member };
+    if (value.nullable || member.nullable) {
+        merged.nullable = true;
+    }
+    return merged;
+};
+export const toSchemaV3 = ({ schema, stackTrail, context }) => {
+    if (isRef(schema)) {
+        return toRefV31({ ref: schema, refType: 'schema', stackTrail, context });
+    }
+    if ('allOf' in schema && Array.isArray(schema.allOf)) {
+        return stackTrail.trace('allOf', st => {
+            const merged = mergeIntersection({
+                schema,
+                getRef: toGetRef(context.documentObject)
+            });
+            return toSchemaV3({ schema: merged, stackTrail: st, context });
+        });
+    }
+    if ('oneOf' in schema && Array.isArray(schema.oneOf)) {
+        return stackTrail.trace('oneOf', st => {
+            const merged = mergeUnion({
+                schema,
+                getRef: toGetRef(context.documentObject),
+                groupType: 'oneOf'
+            });
+            if (!('oneOf' in merged) || !Array.isArray(merged.oneOf)) {
+                throw new Error('Missing "oneOf" array');
+            }
+            const { oneOf: members, ...value } = merged;
+            if (members.length === 0) {
+                throw new Error('"oneOf" array is empty');
+            }
+            if (members.length === 1) {
+                const [soleMember] = members;
+                // A 3.1 nullable reference `oneOf:[{$ref},{type:null}]` down-converts
+                // to a single `$ref` member + a hoisted `nullable:true`. Nullability
+                // here is a *use-site* property — the same refName may be referenced
+                // nullable at one site and not another — so it rides the OasRef node
+                // itself, NOT the shared referent and NOT a synthetic union.
+                // Generators read `ref.nullable` (`'nullable' in schema ?
+                // schema.nullable`) and render `Foo | null`; `ModelDriver` builds the
+                // un-nullable shared `Foo` from the refName. See
+                // notes/openapi-3.1-webhooks-and-parser-architecture.md §3.4.
+                if (isRef(soleMember) && value.nullable) {
+                    return toRefV31({
+                        ref: soleMember,
+                        refType: 'schema',
+                        nullable: true,
+                        stackTrail: st,
+                        context
+                    });
+                }
+                return toSchemaV3({
+                    schema: collapseSingleMember(value, soleMember),
+                    stackTrail: st,
+                    context
+                });
+            }
+            return toUnion({ value, members, parentType: 'oneOf', stackTrail: st, context });
+        });
+    }
+    if ('anyOf' in schema && Array.isArray(schema.anyOf)) {
+        return stackTrail.trace('anyOf', st => {
+            // deno-lint-ignore ban-ts-comment
+            // @ts-expect-error
+            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,
+                getRef: toGetRef(context.documentObject),
+                groupType: 'anyOf'
+            });
+            if (!('anyOf' in merged) || !Array.isArray(merged.anyOf)) {
+                throw new Error('Missing "anyOf" array');
+            }
+            const { anyOf: members, ...value } = merged;
+            if (members.length === 0) {
+                throw new Error('"anyOf" array is empty');
+            }
+            if (members.length === 1) {
+                const [soleMember] = members;
+                // See the oneOf branch: a single `$ref` carrying a hoisted `nullable`
+                // sets `nullable` on the OasRef node itself.
+                if (isRef(soleMember) && value.nullable) {
+                    return toRefV31({
+                        ref: soleMember,
+                        refType: 'schema',
+                        nullable: true,
+                        stackTrail: st,
+                        context
+                    });
+                }
+                return toSchemaV3({
+                    schema: collapseSingleMember(value, soleMember),
+                    stackTrail: st,
+                    context
+                });
+            }
+            return toUnion({ value, members, parentType: 'anyOf', stackTrail: st, 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 });
+        }
+    }
+    // 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 &&
+        typeof value === 'object' &&
+        (('default' in value && typeof value.default === 'string') ||
+            ('example' in value && typeof value.example === 'string') ||
+            ('enum' in value &&
+                Array.isArray(value.enum) &&
+                value.enum.every(item => typeof item === 'string')) ||
+            ('format' in value &&
+                typeof value.format === 'string' &&
+                ['date', 'date-time', 'binary', 'byte'].includes(value.format))));
+};
+const possibleBoolean = (value) => {
+    return (value &&
+        typeof value === 'object' &&
+        (('default' in value && typeof value.default === 'boolean') ||
+            ('example' in value && typeof value.example === 'boolean')));
+};
+const possibleArray = (value) => {
+    return (value &&
+        typeof value === 'object' &&
+        'items' in value &&
+        value.items &&
+        typeof value.items === 'object' &&
+        value.items);
+};
+const possibleObject = (value) => {
+    return (value &&
+        typeof value === 'object' &&
+        'properties' in value &&
+        typeof value.properties === 'object' &&
+        value.properties);
+};
+export const toOptionalSchemaV3 = ({ schema, stackTrail, context }) => {
+    if (!schema) {
+        return undefined;
+    }
+    return toSchemaV3({ schema, stackTrail, context });
+};

package/esm/parse/v3-0/securityRequirement/toSecurityRequirement.d.ts

@@ -0,0 +1,10 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasSecurityRequirement } from '../../../oas/securityRequirement/SecurityRequirement.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSecurityRequirementsV3Args = {
+    security: Record<string, string[]>[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSecurityRequirementsV3: ({ security, stackTrail, context }: ToSecurityRequirementsV3Args) => OasSecurityRequirement[] | undefined;
+//# sourceMappingURL=toSecurityRequirement.d.ts.map

package/esm/parse/v3-0/securityRequirement/toSecurityRequirement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSecurityRequirement.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/securityRequirement/toSecurityRequirement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yDAAyD,CAAA;AAChG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,SAAS,CAAA;IAChD,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAI,mCAItC,4BAA4B,KAAG,sBAAsB,EAAE,GAAG,SAQ5D,CAAA"}

package/esm/parse/v3-0/securityRequirement/toSecurityRequirement.js

@@ -0,0 +1,9 @@
+import { OasSecurityRequirement } from '../../../oas/securityRequirement/SecurityRequirement.js';
+export const toSecurityRequirementsV3 = ({ security, stackTrail, context }) => {
+    if (!security) {
+        return undefined;
+    }
+    return security.map(requirement => {
+        return new OasSecurityRequirement({ requirement }, context.oasDocument);
+    });
+};

package/esm/parse/v3-0/securitySchemes/toSecuritySchemes.d.ts

@@ -0,0 +1,18 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OasSecurityScheme } from '../../../oas/securitySchemes/SecurityScheme.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSecuritySchemesArgs = {
+    securitySchemes: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SecuritySchemeObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSecuritySchemesV3: ({ securitySchemes, stackTrail, context }: ToSecuritySchemesArgs) => // 'http' | 'apiKey' | 'oauth2' | 'openIdConnect'
+Record<string, OasSecurityScheme | OasRef<"securityScheme">> | undefined;
+export type ToSecuritySchemeV3Args = {
+    securityScheme: OpenAPIV3.ReferenceObject | OpenAPIV3.SecuritySchemeObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+//# sourceMappingURL=toSecuritySchemes.d.ts.map

package/esm/parse/v3-0/securitySchemes/toSecuritySchemes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSecuritySchemes.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/securitySchemes/toSecuritySchemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAetE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAA;AAEvF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAIrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,MAAM,MAAM,qBAAqB,GAAG;IAClC,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,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC,GAAG,SAyB9D,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,oBAAoB,CAAA;IAC1E,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA"}

package/esm/parse/v3-0/securitySchemes/toSecuritySchemes.js

@@ -0,0 +1,105 @@
+import { OasHttpSecurityScheme, OasApiKeySecurityScheme, OasOAuth2SecurityScheme, OasOpenIdSecurityScheme } from '../../../oas/securitySchemes/SecurityScheme.js';
+import * as v from 'valibot';
+import { oasApiKeySecuritySchemeData, oasHttpSecuritySchemeData, oasOAuth2SecuritySchemeData, oasOpenIdSecuritySchemeData } from '../../../oas/securitySchemes/security-scheme-types.js';
+import { toRefV31 } from '../ref/toRefV31.js';
+import { isRef } from '../../../helpers/refFns.js';
+import { isEmpty } from '../../../helpers/isEmpty.js';
+import { tryParseAt } from '../../../context/tryParseAt.js';
+export const toSecuritySchemesV3 = ({ securitySchemes, stackTrail, context }) => {
+    if (!securitySchemes) {
+        return undefined;
+    }
+    const output = {};
+    for (const [key, value] of Object.entries(securitySchemes)) {
+        // Isolate per scheme: a single malformed security scheme is logged and
+        // skipped, the rest of the record continues (parity with toSchemasV3).
+        const parsed = tryParseAt({
+            stackTrail,
+            key,
+            context,
+            type: 'INVALID_SECURITY_SCHEME',
+            parent: value,
+            fn: st => toSecuritySchemeV3({ securityScheme: value, stackTrail: st, context })
+        });
+        if (parsed !== undefined) {
+            output[key] = parsed;
+        }
+    }
+    return output;
+};
+const toSecuritySchemeV3 = ({ securityScheme, stackTrail, context }) => {
+    if (isRef(securityScheme)) {
+        return toRefV31({ ref: securityScheme, refType: 'securityScheme', stackTrail, context });
+    }
+    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
+            });
+        }
+        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
+            });
+        }
+        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
+            });
+        }
+        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
+            });
+        }
+        default: {
+            // Exhaustive over the discriminated union: a value reaching here has a
+            // `type` outside the OpenAPI set. `tryParseAt` isolates the throw to
+            // this one scheme.
+            const _exhaustiveCheck = securityScheme;
+            throw new Error(`Unknown security scheme type: ${JSON.stringify(_exhaustiveCheck)}`);
+        }
+    }
+};

package/esm/parse/v3-0/server/toServerV3.d.ts

@@ -0,0 +1,23 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasServer } from '../../../oas/server/Server.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToServersV3Args = {
+    servers: OpenAPIV3.ServerObject[];
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServersV3: ({ servers, stackTrail, context }: ToServersV3Args) => OasServer[];
+export type ToOptionalServersV3Args = {
+    servers: OpenAPIV3.ServerObject[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalServersV3: ({ servers, stackTrail, context }: ToOptionalServersV3Args) => OasServer[] | undefined;
+export type ToServerV3Args = {
+    server: OpenAPIV3.ServerObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServerV3: ({ server, stackTrail, context }: ToServerV3Args) => OasServer;
+//# sourceMappingURL=toServerV3.d.ts.map

package/esm/parse/v3-0/server/toServerV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toServerV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/server/toServerV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,SAAS,CAAC,YAAY,EAAE,CAAA;IACjC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,kCAAkC,eAAe,KAAG,SAAS,EAMxF,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,SAAS,CAAC,YAAY,EAAE,GAAG,SAAS,CAAA;IAC7C,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,kCAIjC,uBAAuB,KAAG,SAAS,EAAE,GAAG,SAM1C,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,SAAS,CAAC,YAAY,CAAA;IAC9B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,iCAAiC,cAAc,KAAG,SAiB5E,CAAA"}

package/esm/parse/v3-0/server/toServerV3.js

@@ -0,0 +1,30 @@
+import { OasServer } from '../../../oas/server/Server.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toOptionalServerVariablesV3 } from '../serverVariable/toServerVariableV3.js';
+export const toServersV3 = ({ servers, stackTrail, context }) => {
+    return servers.map((server, index) => {
+        return stackTrail.trace(server.url ?? index, st => toServerV3({ server, stackTrail: st, context }));
+    });
+};
+export const toOptionalServersV3 = ({ servers, stackTrail, context }) => {
+    if (!servers) {
+        return undefined;
+    }
+    return toServersV3({ servers, stackTrail, context });
+};
+export const toServerV3 = ({ server, stackTrail, context }) => {
+    const { description, url, variables, ...skipped } = server;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: server,
+        context,
+        stackTrail,
+        parentType: 'server'
+    });
+    return new OasServer({
+        description,
+        url,
+        variables: toOptionalServerVariablesV3({ serverVariables: variables, stackTrail, context }),
+        extensionFields
+    });
+};

package/esm/parse/v3-0/serverVariable/toServerVariableV3.d.ts

@@ -0,0 +1,23 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasServerVariable } from '../../../oas/serverVariable/ServerVariable.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToServerVariablesV3Args = {
+    serverVariables: Record<string, OpenAPIV3.ServerVariableObject>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServerVariablesV3: ({ serverVariables, stackTrail, context }: ToServerVariablesV3Args) => Record<string, OasServerVariable>;
+export type ToOptionalServerVariablesV3Args = {
+    serverVariables: Record<string, OpenAPIV3.ServerVariableObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalServerVariablesV3: ({ serverVariables, stackTrail, context }: ToOptionalServerVariablesV3Args) => Record<string, OasServerVariable> | undefined;
+export type ToServerVariableV3Args = {
+    serverVariable: OpenAPIV3.ServerVariableObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServerVariableV3: ({ serverVariable, stackTrail, context }: ToServerVariableV3Args) => OasServerVariable;
+//# sourceMappingURL=toServerVariableV3.d.ts.map

package/esm/parse/v3-0/serverVariable/toServerVariableV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toServerVariableV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/serverVariable/toServerVariableV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAA;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAA;IAC/D,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,0CAIjC,uBAAuB,KAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAO5D,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG;IAC5C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAA;IAC3E,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,2BAA2B,GAAI,0CAIzC,+BAA+B,KAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAMxE,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,SAAS,CAAC,oBAAoB,CAAA;IAC9C,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,yCAIhC,sBAAsB,KAAG,iBAiB3B,CAAA"}

package/esm/parse/v3-0/serverVariable/toServerVariableV3.js

@@ -0,0 +1,30 @@
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { OasServerVariable } from '../../../oas/serverVariable/ServerVariable.js';
+export const toServerVariablesV3 = ({ serverVariables, stackTrail, context }) => {
+    return Object.fromEntries(Object.entries(serverVariables).map(([key, serverVariable]) => [
+        key,
+        toServerVariableV3({ serverVariable, stackTrail, context })
+    ]));
+};
+export const toOptionalServerVariablesV3 = ({ serverVariables, stackTrail, context }) => {
+    if (!serverVariables) {
+        return undefined;
+    }
+    return toServerVariablesV3({ serverVariables, stackTrail, context });
+};
+export const toServerVariableV3 = ({ serverVariable, stackTrail, context }) => {
+    const { description, default: defaultValue, enum: enums, ...skipped } = serverVariable;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: serverVariable,
+        context,
+        stackTrail,
+        parentType: 'serverVariable'
+    });
+    return new OasServerVariable({
+        description,
+        default: defaultValue,
+        enums,
+        extensionFields
+    });
+};

package/esm/parse/v3-0/specificationExtensions/toSpecificationExtensionsV3.d.ts

@@ -0,0 +1,15 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSpecificationExtensionsV3Args = {
+    skipped: Record<string, unknown>;
+    parent: unknown;
+    parentType: string;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSpecificationExtensionsV3: ({ skipped: s, parent, parentType, stackTrail, context }: ToSpecificationExtensionsV3Args) => Record<string, unknown> | undefined;
+export declare const extractExtensions: (item: Record<string, unknown>) => {
+    skipped: Record<string, unknown> | undefined;
+    extensionFields: Record<string, unknown> | undefined;
+};
+//# sourceMappingURL=toSpecificationExtensionsV3.d.ts.map

package/esm/parse/v3-0/specificationExtensions/toSpecificationExtensionsV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSpecificationExtensionsV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/specificationExtensions/toSpecificationExtensionsV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,+BAA+B,GAAG;IAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,MAAM,EAAE,OAAO,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,2BAA2B,GAAI,yDAMzC,+BAA+B,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAQ9D,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;CAkB9D,CAAA"}

package/esm/parse/v3-0/specificationExtensions/toSpecificationExtensionsV3.js

@@ -0,0 +1,25 @@
+import { isEmpty } from '../../../helpers/isEmpty.js';
+export const toSpecificationExtensionsV3 = ({ skipped: s, parent, parentType, stackTrail, context }) => {
+    const { skipped, extensionFields } = extractExtensions(s);
+    if (skipped) {
+        context.logSkippedFields({ skipped, parent, stackTrail, parentType });
+    }
+    return extensionFields;
+};
+export const extractExtensions = (item) => {
+    const entries = Object.entries(item);
+    const skipped = {};
+    const extensionFields = {};
+    for (const [key, value] of entries) {
+        if (!key.startsWith('x-')) {
+            skipped[key] = value;
+        }
+        else {
+            extensionFields[key] = value;
+        }
+    }
+    return {
+        skipped: isEmpty(skipped) ? undefined : skipped,
+        extensionFields: isEmpty(extensionFields) ? undefined : extensionFields
+    };
+};