@skmtc/core 0.29.0 → 0.31.0

package/script/parse/v3-1/securitySchemes/toSecuritySchemes.js

@@ -39,8 +39,8 @@ const v = __importStar(require("valibot"));
 const security_scheme_types_js_1 = require("../../../oas/securitySchemes/security-scheme-types.js");
 const toRefV31_js_1 = require("../ref/toRefV31.js");
 const refFns_js_1 = require("../../../helpers/refFns.js");
-const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
 const tryParseAt_js_1 = require("../../../context/tryParseAt.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
 const toSecuritySchemesV3 = ({ securitySchemes, stackTrail, context }) => {
     if (!securitySchemes) {
         return undefined;
@@ -64,21 +64,29 @@ const toSecuritySchemesV3 = ({ securitySchemes, stackTrail, context }) => {
     return output;
 };
 exports.toSecuritySchemesV3 = toSecuritySchemesV3;
+/**
+ * Log the keys of `value` that `known` does not name as skipped fields.
+ * `v.parse` on a `v.object` schema strips unknown keys, so they are read
+ * off the raw object. `x-` extensions are not logged.
+ */
+const logSkippedKeys = ({ value, known, parentType, stackTrail, context }) => {
+    const skipped = Object.fromEntries(Object.entries(value).filter(([key]) => !Object.hasOwn(known, key)));
+    (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({ skipped, parent: value, parentType, stackTrail, context });
+};
 const toSecuritySchemeV3 = ({ securityScheme, stackTrail, context }) => {
     if ((0, refFns_js_1.isRef)(securityScheme)) {
         return (0, toRefV31_js_1.toRefV31)({ ref: securityScheme, refType: 'securityScheme', stackTrail, context });
     }
     switch (securityScheme.type) {
         case 'http': {
-            const { type: _type, description, scheme, bearerFormat, ...skipped } = v.parse(security_scheme_types_js_1.oasHttpSecuritySchemeData, securityScheme);
-            if (!(0, isEmpty_js_1.isEmpty)(skipped)) {
-                context.logSkippedFields({
-                    skipped,
-                    parent: securityScheme,
-                    stackTrail,
-                    parentType: 'securityScheme:http'
-                });
-            }
+            const { description, scheme, bearerFormat } = v.parse(security_scheme_types_js_1.oasHttpSecuritySchemeData, securityScheme);
+            logSkippedKeys({
+                value: securityScheme,
+                known: security_scheme_types_js_1.oasHttpSecuritySchemeData.entries,
+                parentType: 'securityScheme:http',
+                stackTrail,
+                context
+            });
             return new SecurityScheme_js_1.OasHttpSecurityScheme({
                 description,
                 scheme,
@@ -86,15 +94,14 @@ const toSecuritySchemeV3 = ({ securityScheme, stackTrail, context }) => {
             });
         }
         case 'apiKey': {
-            const { type: _type, in: location, description, name, ...skipped } = v.parse(security_scheme_types_js_1.oasApiKeySecuritySchemeData, securityScheme);
-            if (!(0, isEmpty_js_1.isEmpty)(skipped)) {
-                context.logSkippedFields({
-                    skipped,
-                    parent: securityScheme,
-                    stackTrail,
-                    parentType: 'securityScheme:apiKey'
-                });
-            }
+            const { in: location, description, name } = v.parse(security_scheme_types_js_1.oasApiKeySecuritySchemeData, securityScheme);
+            logSkippedKeys({
+                value: securityScheme,
+                known: security_scheme_types_js_1.oasApiKeySecuritySchemeData.entries,
+                parentType: 'securityScheme:apiKey',
+                stackTrail,
+                context
+            });
             return new SecurityScheme_js_1.OasApiKeySecurityScheme({
                 description,
                 name,
@@ -102,30 +109,35 @@ const toSecuritySchemeV3 = ({ securityScheme, stackTrail, context }) => {
             });
         }
         case 'oauth2': {
-            const { type: _type, flows, description, ...skipped } = v.parse(security_scheme_types_js_1.oasOAuth2SecuritySchemeData, securityScheme);
-            if (!(0, isEmpty_js_1.isEmpty)(skipped)) {
-                context.logSkippedFields({
-                    skipped,
-                    parent: securityScheme,
-                    stackTrail,
-                    parentType: 'securityScheme:oauth2'
-                });
-            }
+            const { flows, description } = v.parse(security_scheme_types_js_1.oasOAuth2SecuritySchemeData, securityScheme);
+            logSkippedKeys({
+                value: securityScheme,
+                known: security_scheme_types_js_1.oasOAuth2SecuritySchemeData.entries,
+                parentType: 'securityScheme:oauth2',
+                stackTrail,
+                context
+            });
+            stackTrail.trace('flows', st => logSkippedKeys({
+                value: securityScheme.flows,
+                known: security_scheme_types_js_1.oasOAuth2FlowsData.entries,
+                parentType: 'oauthFlows',
+                stackTrail: st,
+                context
+            }));
             return new SecurityScheme_js_1.OasOAuth2SecurityScheme({
                 description,
                 flows
             });
         }
         case 'openIdConnect': {
-            const { type: _type, description, openIdConnectUrl, ...skipped } = v.parse(security_scheme_types_js_1.oasOpenIdSecuritySchemeData, securityScheme);
-            if (!(0, isEmpty_js_1.isEmpty)(skipped)) {
-                context.logSkippedFields({
-                    skipped,
-                    parent: securityScheme,
-                    stackTrail,
-                    parentType: 'securityScheme:openIdConnect'
-                });
-            }
+            const { description, openIdConnectUrl } = v.parse(security_scheme_types_js_1.oasOpenIdSecuritySchemeData, securityScheme);
+            logSkippedKeys({
+                value: securityScheme,
+                known: security_scheme_types_js_1.oasOpenIdSecuritySchemeData.entries,
+                parentType: 'securityScheme:openIdConnect',
+                stackTrail,
+                context
+            });
             return new SecurityScheme_js_1.OasOpenIdSecurityScheme({
                 description,
                 openIdConnectUrl

package/script/parse/v3-1/webhook/toWebhooksV3.js

@@ -6,7 +6,7 @@ const toResponseV3_js_1 = require("../response/toResponseV3.js");
 const toParameterV3_js_1 = require("../parameter/toParameterV3.js");
 const Webhook_js_1 = require("../../../oas/webhook/Webhook.js");
 const toPathItemV3_js_1 = require("../pathItem/toPathItemV3.js");
-const Method_js_1 = require("../../../types/Method.js");
+const methods_js_1 = require("../methods.js");
 const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
 const toSecurityRequirement_js_1 = require("../securityRequirement/toSecurityRequirement.js");
 const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
@@ -73,14 +73,14 @@ const toWebhooksV3 = ({ webhooks, stackTrail, context }) => {
                 return [];
             }
             const cleaned = Object.entries(pathItem).reduce(({ rest, methodObject }, [key, operation]) => {
-                const isMethod = Method_js_1.methodValues.includes(key);
-                if (isMethod) {
-                    const { [key]: _deleted, ...remaining } = rest;
+                const method = (0, methods_js_1.toPathItemMethod)(key);
+                if (method) {
+                    const { [method]: _deleted, ...remaining } = rest;
                     return {
                         rest: remaining,
                         methodObject: {
                             ...methodObject,
-                            [key]: operation
+                            [method]: operation
                         }
                     };
                 }

package/script/parse/v3-2/_helpers/parseDefault.d.ts

@@ -0,0 +1,43 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the `default` property from OpenAPI schemas.
+ *
+ * @template Value - The narrowed type a valid (non-null) default holds
+ */
+export type ParseDefaultArgs<Value> = {
+    /** The raw `default` value extracted from the schema */
+    value: unknown;
+    /** The parsed nullable flag — `null` is only a valid default when this is `true` */
+    nullable: boolean | undefined;
+    /** The surrounding schema object, used as the issue location's parent */
+    parent: unknown;
+    /** Type guard narrowing an acceptable non-null default to `Value` */
+    check: (item: unknown) => item is Value;
+    /** Builds the warning message for a rejected default */
+    toMessage: (item: unknown) => string;
+    /** Parse context for logging issues */
+    context: ParseContextType;
+    /** Stack trail for tracking the current parsing location */
+    stackTrail: StackTrail;
+};
+/**
+ * Parses and validates the `default` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no default present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_DEFAULT` warning and dropped
+ *
+ * This mirrors the OpenAPI 3.0 rule that a `default` MUST conform to the
+ * schema's type, where `nullable: true` widens that type to include `null`.
+ * The function is fail-open: an invalid default is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid default holds
+ * @param args - Parsing configuration
+ * @returns The validated default (`Value`), `null` (nullable), or `undefined`
+ */
+export declare const parseDefault: <Value>({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseDefaultArgs<Value>) => Value | null | undefined;

package/script/parse/v3-2/_helpers/parseDefault.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDefault = void 0;
+/**
+ * Parses and validates the `default` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no default present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_DEFAULT` warning and dropped
+ *
+ * This mirrors the OpenAPI 3.0 rule that a `default` MUST conform to the
+ * schema's type, where `nullable: true` widens that type to include `null`.
+ * The function is fail-open: an invalid default is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid default holds
+ * @param args - Parsing configuration
+ * @returns The validated default (`Value`), `null` (nullable), or `undefined`
+ */
+const parseDefault = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (nullable && value === null) {
+        return null;
+    }
+    if (!check(value)) {
+        context.logIssue({
+            key: 'default',
+            level: 'warning',
+            message: toMessage(value),
+            parent,
+            stackTrail,
+            type: 'INVALID_DEFAULT'
+        });
+        return undefined;
+    }
+    return value;
+};
+exports.parseDefault = parseDefault;

package/script/parse/v3-2/_helpers/parseEnum.d.ts

@@ -0,0 +1,13 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+type ParseEnumArgs = {
+    value: unknown;
+    nullable: boolean | undefined;
+    parent: unknown;
+    check: (item: unknown) => boolean;
+    toMessage: (item: unknown) => string;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+export declare const parseEnum: ({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseEnumArgs) => any[] | undefined;
+export {};

package/script/parse/v3-2/_helpers/parseEnum.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnum = void 0;
+const parseEnum = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (nullable && item === null) {
+                continue;
+            }
+            if (check(item)) {
+                continue;
+            }
+            context.logIssue({
+                key: 'enum',
+                level: 'warning',
+                message: toMessage(item),
+                parent,
+                stackTrail,
+                type: 'INVALID_ENUM'
+            });
+            return undefined;
+        }
+        return value;
+    }
+    return undefined;
+};
+exports.parseEnum = parseEnum;

package/script/parse/v3-2/_helpers/parseExample.d.ts

@@ -0,0 +1,41 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the `example` property from OpenAPI schemas.
+ *
+ * @template Value - The narrowed type a valid (non-null) example holds
+ */
+export type ParseExampleArgs<Value> = {
+    /** The raw `example` value extracted from the schema */
+    value: unknown;
+    /** The parsed nullable flag — `null` is only a valid example when this is `true` */
+    nullable: boolean | undefined;
+    /** The surrounding schema object, used as the issue location's parent */
+    parent: unknown;
+    /** Type guard narrowing an acceptable non-null example to `Value` */
+    check: (item: unknown) => item is Value;
+    /** Builds the warning message for a rejected example */
+    toMessage: (item: unknown) => string;
+    /** Parse context for logging issues */
+    context: ParseContextType;
+    /** Stack trail for tracking the current parsing location */
+    stackTrail: StackTrail;
+};
+/**
+ * Parses and validates the `example` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no example present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_EXAMPLE` warning and dropped
+ *
+ * The function is fail-open: an invalid example is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid example holds
+ * @param args - Parsing configuration
+ * @returns The validated example (`Value`), `null` (nullable), or `undefined`
+ */
+export declare const parseExample: <Value>({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseExampleArgs<Value>) => Value | null | undefined;

package/script/parse/v3-2/_helpers/parseExample.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExample = void 0;
+/**
+ * Parses and validates the `example` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no example present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_EXAMPLE` warning and dropped
+ *
+ * The function is fail-open: an invalid example is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid example holds
+ * @param args - Parsing configuration
+ * @returns The validated example (`Value`), `null` (nullable), or `undefined`
+ */
+const parseExample = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (nullable && value === null) {
+        return null;
+    }
+    if (!check(value)) {
+        context.logIssue({
+            key: 'example',
+            level: 'warning',
+            message: toMessage(value),
+            parent,
+            stackTrail,
+            type: 'INVALID_EXAMPLE'
+        });
+        return undefined;
+    }
+    return value;
+};
+exports.parseExample = parseExample;

package/script/parse/v3-2/_helpers/parseNullable.d.ts

@@ -0,0 +1,141 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the nullable property from OpenAPI schemas.
+ *
+ * @template Value - The OpenAPI schema object type
+ */
+export type ParseNullableArgs<Value extends OpenAPIV3.SchemaObject> = {
+    /** The OpenAPI schema object containing the nullable property */
+    value: Value;
+    /** Stack trail for tracking current parsing context */
+    stackTrail: StackTrail;
+    /** Parse context for error handling */
+    context: ParseContextType;
+};
+/**
+ * Return type for parsed nullable data.
+ *
+ * @template Value - The OpenAPI schema object type
+ */
+export type ParseNullableReturn<Value extends OpenAPIV3.SchemaObject> = {
+    /** The validated nullable flag (true, false, or undefined) */
+    nullable: boolean | undefined;
+    /** The schema object without the nullable property */
+    value: Omit<Value, 'nullable'>;
+};
+/**
+ * Parses and validates the nullable property from OpenAPI schema objects.
+ *
+ * This function extracts and validates the `nullable` property from OpenAPI
+ * schema objects, ensuring it's a valid boolean value. Invalid nullable values
+ * are removed and logged as warnings through the parse context.
+ *
+ * The nullable property determines whether a schema value can be null in addition
+ * to its primary type, which affects type generation and validation logic.
+ *
+ * @template Value - The OpenAPI schema object type
+ *
+ * @param args - Parsing configuration
+ * @returns Parsed nullable data with the validated flag and cleaned schema
+ *
+ * @example Valid nullable property
+ * ```typescript
+ * import { parseNullable } from '@skmtc/core/oas/_helpers';
+ *
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     nullable: true,
+ *     description: 'An optional string that can be null'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * console.log(result.value);    // { type: 'string', description: 'An optional string that can be null' }
+ * ```
+ *
+ * @example Explicitly non-nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'number',
+ *     nullable: false,
+ *     minimum: 0
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // false
+ * console.log(result.value);    // { type: 'number', minimum: 0 }
+ * ```
+ *
+ * @example Missing nullable property (undefined)
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     format: 'email'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (property not present)
+ * console.log(result.value);    // { type: 'string', format: 'email' }
+ * ```
+ *
+ * @example Invalid nullable value
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'boolean',
+ *     nullable: 'yes', // Invalid - should be boolean
+ *     description: 'A flag'
+ *   } as any,
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (invalid value removed)
+ * console.log(result.value);    // { type: 'boolean', description: 'A flag' }
+ * // Context will log a warning about the invalid nullable value
+ * ```
+ *
+ * @example Usage in type generation
+ * ```typescript
+ * function generateTypeScript(schema: OpenAPIV3.SchemaObject) {
+ *   const { nullable, value } = parseNullable({ value: schema, context });
+ *
+ *   const baseType = generateBaseType(value);
+ *   const nullableType = nullable ? ` | null` : '';
+ *
+ *   return `${baseType}${nullableType}`;
+ * }
+ *
+ * // Examples:
+ * // nullable: true  -> 'string | null'
+ * // nullable: false -> 'string'
+ * // nullable: undefined -> 'string' (default behavior)
+ * ```
+ *
+ * @example Complex schema with nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       age: { type: 'number' }
+ *     },
+ *     required: ['name'],
+ *     nullable: true // The entire object can be null
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * // Generated type might be: { name: string; age?: number } | null
+ * ```
+ */
+export declare const parseNullable: <Value extends OpenAPIV3.SchemaObject>({ value, stackTrail, context }: ParseNullableArgs<Value>) => ParseNullableReturn<Value>;

package/script/parse/v3-2/_helpers/parseNullable.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNullable = void 0;
+/**
+ * Parses and validates the nullable property from OpenAPI schema objects.
+ *
+ * This function extracts and validates the `nullable` property from OpenAPI
+ * schema objects, ensuring it's a valid boolean value. Invalid nullable values
+ * are removed and logged as warnings through the parse context.
+ *
+ * The nullable property determines whether a schema value can be null in addition
+ * to its primary type, which affects type generation and validation logic.
+ *
+ * @template Value - The OpenAPI schema object type
+ *
+ * @param args - Parsing configuration
+ * @returns Parsed nullable data with the validated flag and cleaned schema
+ *
+ * @example Valid nullable property
+ * ```typescript
+ * import { parseNullable } from '@skmtc/core/oas/_helpers';
+ *
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     nullable: true,
+ *     description: 'An optional string that can be null'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * console.log(result.value);    // { type: 'string', description: 'An optional string that can be null' }
+ * ```
+ *
+ * @example Explicitly non-nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'number',
+ *     nullable: false,
+ *     minimum: 0
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // false
+ * console.log(result.value);    // { type: 'number', minimum: 0 }
+ * ```
+ *
+ * @example Missing nullable property (undefined)
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     format: 'email'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (property not present)
+ * console.log(result.value);    // { type: 'string', format: 'email' }
+ * ```
+ *
+ * @example Invalid nullable value
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'boolean',
+ *     nullable: 'yes', // Invalid - should be boolean
+ *     description: 'A flag'
+ *   } as any,
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (invalid value removed)
+ * console.log(result.value);    // { type: 'boolean', description: 'A flag' }
+ * // Context will log a warning about the invalid nullable value
+ * ```
+ *
+ * @example Usage in type generation
+ * ```typescript
+ * function generateTypeScript(schema: OpenAPIV3.SchemaObject) {
+ *   const { nullable, value } = parseNullable({ value: schema, context });
+ *
+ *   const baseType = generateBaseType(value);
+ *   const nullableType = nullable ? ` | null` : '';
+ *
+ *   return `${baseType}${nullableType}`;
+ * }
+ *
+ * // Examples:
+ * // nullable: true  -> 'string | null'
+ * // nullable: false -> 'string'
+ * // nullable: undefined -> 'string' (default behavior)
+ * ```
+ *
+ * @example Complex schema with nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       age: { type: 'number' }
+ *     },
+ *     required: ['name'],
+ *     nullable: true // The entire object can be null
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * // Generated type might be: { name: string; age?: number } | null
+ * ```
+ */
+const parseNullable = ({ value, stackTrail, context }) => {
+    if (value.nullable === undefined) {
+        return {
+            nullable: undefined,
+            value: value
+        };
+    }
+    const { nullable, ...rest } = value;
+    if (typeof nullable === 'boolean') {
+        return {
+            nullable: nullable,
+            value: rest
+        };
+    }
+    context.logIssue({
+        key: 'nullable',
+        stackTrail,
+        parent: value,
+        level: 'warning',
+        message: `Invalid nullable: ${value}`,
+        type: 'INVALID_NULLABLE'
+    });
+    return {
+        nullable: undefined,
+        value: rest
+    };
+};
+exports.parseNullable = parseNullable;

package/script/parse/v3-2/_merge-all-of/check-array-item-type-conflicts.d.ts

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkArrayItemTypeConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;

package/script/parse/v3-2/_merge-all-of/check-array-item-type-conflicts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArrayItemTypeConflicts = void 0;
+const checkArrayItemTypeConflicts = (a, b) => {
+    if (a.type === 'array' && b.type === 'array' && 'items' in a && 'items' in b) {
+        const aItems = a.items;
+        const bItems = b.items;
+        if (aItems.type && bItems.type && aItems.type !== bItems.type) {
+            throw new Error(`Cannot merge schemas: array items have conflicting types '${aItems.type}' and '${bItems.type}'`);
+        }
+    }
+};
+exports.checkArrayItemTypeConflicts = checkArrayItemTypeConflicts;