@mintlify/validation 0.1.395 → 0.1.397

package/dist/mint-config/validateConfig.d.ts

@@ -813,6 +813,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
     contextual?: {
         options: ("copy" | "view" | "chatgpt" | "claude")[];
     } | undefined;
+    thumbnails?: {
+        appearance?: import("../index.js").ThumbnailAppearance | undefined;
+        background?: string | undefined;
+    } | undefined;
 } | {
     name: string;
     theme: "aspen";
@@ -1150,6 +1154,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
     contextual?: {
         options: ("copy" | "view" | "chatgpt" | "claude")[];
     } | undefined;
+    thumbnails?: {
+        appearance?: import("../index.js").ThumbnailAppearance | undefined;
+        background?: string | undefined;
+    } | undefined;
 } | {
     name: string;
     theme: "linden";
@@ -1487,6 +1495,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
     contextual?: {
         options: ("copy" | "view" | "chatgpt" | "claude")[];
     } | undefined;
+    thumbnails?: {
+        appearance?: import("../index.js").ThumbnailAppearance | undefined;
+        background?: string | undefined;
+    } | undefined;
 } | {
     name: string;
     theme: "maple";
@@ -1824,6 +1836,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
     contextual?: {
         options: ("copy" | "view" | "chatgpt" | "claude")[];
     } | undefined;
+    thumbnails?: {
+        appearance?: import("../index.js").ThumbnailAppearance | undefined;
+        background?: string | undefined;
+    } | undefined;
 } | {
     name: string;
     theme: "mint";
@@ -2161,6 +2177,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
     contextual?: {
         options: ("copy" | "view" | "chatgpt" | "claude")[];
     } | undefined;
+    thumbnails?: {
+        appearance?: import("../index.js").ThumbnailAppearance | undefined;
+        background?: string | undefined;
+    } | undefined;
 } | {
     name: string;
     theme: "palm";
@@ -2498,6 +2518,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
     contextual?: {
         options: ("copy" | "view" | "chatgpt" | "claude")[];
     } | undefined;
+    thumbnails?: {
+        appearance?: import("../index.js").ThumbnailAppearance | undefined;
+        background?: string | undefined;
+    } | undefined;
 } | {
     name: string;
     theme: "willow";
@@ -2835,6 +2859,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
     contextual?: {
         options: ("copy" | "view" | "chatgpt" | "claude")[];
     } | undefined;
+    thumbnails?: {
+        appearance?: import("../index.js").ThumbnailAppearance | undefined;
+        background?: string | undefined;
+    } | undefined;
 }> | {
     warnings: z.ZodIssue[];
     success: true;
@@ -3175,6 +3203,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
         contextual?: {
             options: ("copy" | "view" | "chatgpt" | "claude")[];
         } | undefined;
+        thumbnails?: {
+            appearance?: import("../index.js").ThumbnailAppearance | undefined;
+            background?: string | undefined;
+        } | undefined;
     } | {
         name: string;
         $schema: string;
@@ -3512,6 +3544,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
         contextual?: {
             options: ("copy" | "view" | "chatgpt" | "claude")[];
         } | undefined;
+        thumbnails?: {
+            appearance?: import("../index.js").ThumbnailAppearance | undefined;
+            background?: string | undefined;
+        } | undefined;
     } | {
         name: string;
         $schema: string;
@@ -3849,6 +3885,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
         contextual?: {
             options: ("copy" | "view" | "chatgpt" | "claude")[];
         } | undefined;
+        thumbnails?: {
+            appearance?: import("../index.js").ThumbnailAppearance | undefined;
+            background?: string | undefined;
+        } | undefined;
     } | {
         name: string;
         $schema: string;
@@ -4186,6 +4226,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
         contextual?: {
             options: ("copy" | "view" | "chatgpt" | "claude")[];
         } | undefined;
+        thumbnails?: {
+            appearance?: import("../index.js").ThumbnailAppearance | undefined;
+            background?: string | undefined;
+        } | undefined;
     } | {
         name: string;
         $schema: string;
@@ -4523,6 +4567,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
         contextual?: {
             options: ("copy" | "view" | "chatgpt" | "claude")[];
         } | undefined;
+        thumbnails?: {
+            appearance?: import("../index.js").ThumbnailAppearance | undefined;
+            background?: string | undefined;
+        } | undefined;
     } | {
         name: string;
         $schema: string;
@@ -4860,6 +4908,10 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
         contextual?: {
             options: ("copy" | "view" | "chatgpt" | "claude")[];
         } | undefined;
+        thumbnails?: {
+            appearance?: import("../index.js").ThumbnailAppearance | undefined;
+            background?: string | undefined;
+        } | undefined;
     } | {
         name: string;
         $schema: string;
@@ -5197,5 +5249,9 @@ export declare function validateDocsConfig(value: unknown): z.SafeParseError<{
         contextual?: {
             options: ("copy" | "view" | "chatgpt" | "claude")[];
         } | undefined;
+        thumbnails?: {
+            appearance?: import("../index.js").ThumbnailAppearance | undefined;
+            background?: string | undefined;
+        } | undefined;
     };
 };

package/dist/openapi/IncrementalEvaluator.d.ts

@@ -1,15 +1,5 @@
-import { OpenAPIV3_1 } from 'openapi-types';
 import { IncrementalDataSchemaArray } from './types/endpoint.js';
-type Schema3_1 = OpenAPIV3_1.SchemaObject;
-type Ref = OpenAPIV3_1.ReferenceObject;
-type SchemaOrRef = Schema3_1 | Ref;
-type Compositions = 'allOf' | 'oneOf' | 'anyOf' | 'not';
-export type SimpleSchema = Omit<OpenAPIV3_1.SchemaObject, Compositions> & {
-    items?: OpenAPIV3_1.SchemaObject;
-    refIdentifier?: string;
-    _depth?: number;
-};
-export type SumOfProducts = SimpleSchema[][];
+import { SimpleSchema, SchemaOrRef, Schema3_1, SumOfProducts, SchemaOrRefComposition } from './types/schema.js';
 /**
  * Given an OpenAPI 3.1 SchemaObject or ReferenceObject containing any number of
  * refs or compositions, this function returns the schema in sum-of-products form.
@@ -39,7 +29,7 @@ export type SumOfProducts = SimpleSchema[][];
  * @param componentSchemas The value of `document.components.schemas`, to be used when dereferencing
  * @returns The schema in sum-of-products form
  */
-export declare function reduceToSumOfProducts(schemaOrRef: SchemaOrRef, componentSchemas: Record<string, Schema3_1> | undefined, opts?: {
+export declare function reduceToSumOfProducts(schemaOrRef: SchemaOrRefComposition, componentSchemas: Record<string, Schema3_1> | undefined, opts?: {
     isRoot?: true;
     _depth?: number;
 }): SumOfProducts;
@@ -60,4 +50,3 @@ export declare function reduceToSumOfProducts(schemaOrRef: SchemaOrRef, componen
 export declare function combineSimpleSchemas(schemas: SimpleSchema[], componentSchemas: Record<string, Schema3_1> | undefined, location?: 'request' | 'response'): SimpleSchema;
 export declare function generateFirstIncrementalSchema(schema: SchemaOrRef | undefined, componentSchemas: Record<string, Schema3_1> | undefined, required?: boolean, location?: 'request' | 'response', contentType?: string): IncrementalDataSchemaArray;
 export declare function generateNextIncrementalSchema(schema: SchemaOrRef, componentSchemas: Record<string, Schema3_1> | undefined, required?: boolean, location?: 'request' | 'response'): IncrementalDataSchemaArray;
-export {};

package/dist/openapi/IncrementalEvaluator.js

@@ -1,6 +1,5 @@
-import lcm from 'lcm';
 import { inferType } from './SchemaConverter.js';
-import { addKeyIfDefined, copyExampleIfDefined, copyKeyIfDefined, dereference, recursivelyFindDescription, stringFileFormats, structuredDataContentTypes, } from './utils.js';
+import { addKeyIfDefined, copyExampleIfDefined, copyKeyIfDefined, dereference, mergeTypes, normalizeMinMax, stringFileFormats, structuredDataContentTypes, sortSchemas, combineExamples, combineProperties, combineDescription, combineAdditionalProperties, copyAndCombineKeys, combineTitle, discriminatorAndSchemaRefsMatch, } from './utils.js';
 function hasSchemaContent(schema) {
     const meaningfulKeys = Object.keys(schema).filter((key) => !key.startsWith('_'));
     return meaningfulKeys.length > 0;
@@ -47,14 +46,17 @@ export function reduceToSumOfProducts(schemaOrRef, componentSchemas, opts) {
             ((_b = dereferencedSchema.allOf) === null || _b === void 0 ? void 0 : _b.find((subschema) => 'type' in subschema && subschema.type === 'object'))) {
             dereferencedSchema.type = 'object';
         }
-        schema = Object.assign(Object.assign({}, dereferencedSchema), { 
-            // @ts-expect-error some customers use title even though it's not part of the spec
-            title: (_c = schemaOrRef.title) !== null && _c !== void 0 ? _c : dereferencedSchema.title, refIdentifier: refIdentifier, description: (_d = schemaOrRef.description) !== null && _d !== void 0 ? _d : dereferencedSchema.description });
+        // @ts-expect-error some customers use title even though it's not part of the spec
+        const dereferencedSchemaTitle = (_c = schemaOrRef.title) !== null && _c !== void 0 ? _c : dereferencedSchema.title;
+        schema = Object.assign(Object.assign({}, dereferencedSchema), { title: dereferencedSchemaTitle, refIdentifier: refIdentifier, description: (_d = schemaOrRef.description) !== null && _d !== void 0 ? _d : dereferencedSchema.description, isOneOf: schemaOrRef.isOneOf, isAnyOf: schemaOrRef.isAnyOf, isAllOf: schemaOrRef.isAllOf });
     }
     else {
         schema = schemaOrRef;
     }
-    if ((opts === null || opts === void 0 ? void 0 : opts.isRoot) && schema.type === 'array' && ((_e = schema.discriminator) === null || _e === void 0 ? void 0 : _e.mapping)) {
+    if ((opts === null || opts === void 0 ? void 0 : opts.isRoot) &&
+        schema.type === 'array' &&
+        ((_e = schema.discriminator) === null || _e === void 0 ? void 0 : _e.mapping) &&
+        !discriminatorAndSchemaRefsMatch(schema)) {
         const discriminator = schema.discriminator;
         const baseItemSchema = schema.items;
         delete schema.discriminator;
@@ -90,7 +92,11 @@ export function reduceToSumOfProducts(schemaOrRef, componentSchemas, opts) {
         });
         schema = Object.assign(Object.assign({}, schema), { items: Object.assign(Object.assign({}, baseItemSchema), { oneOf: [...processedDiscriminatedTypes, ...extraItems] }) });
     }
-    else if ((opts === null || opts === void 0 ? void 0 : opts.isRoot) && ((_j = schema.discriminator) === null || _j === void 0 ? void 0 : _j.mapping) && !schema.oneOf && !schema.allOf) {
+    else if ((opts === null || opts === void 0 ? void 0 : opts.isRoot) &&
+        ((_j = schema.discriminator) === null || _j === void 0 ? void 0 : _j.mapping) &&
+        !schema.oneOf &&
+        !schema.allOf &&
+        !discriminatorAndSchemaRefsMatch(schema)) {
         const properties = Object.values(schema.discriminator.mapping);
         if (properties.length) {
             delete schema.discriminator;
@@ -122,18 +128,36 @@ export function reduceToSumOfProducts(schemaOrRef, componentSchemas, opts) {
     const baseSchemaArr = hasSchemaContent(baseSchema)
         ? [baseSchemaTypes.map((type) => [Object.assign(Object.assign({}, baseSchema), { type })])]
         : [];
-    const reducedOneOfs = (_k = schema.oneOf) === null || _k === void 0 ? void 0 : _k.map((subschema) => reduceToSumOfProducts(subschema, componentSchemas, { _depth: _depth + 1 }));
-    const reducedAnyOfs = (_l = schema.anyOf) === null || _l === void 0 ? void 0 : _l.map((subschema) => reduceToSumOfProducts(subschema, componentSchemas, { _depth: _depth + 1 }));
-    const reducedAllOfs = (_m = schema.allOf) === null || _m === void 0 ? void 0 : _m.map((subschema) => reduceToSumOfProducts(subschema, componentSchemas, { _depth: _depth + 1 }));
+    const reducedOneOfs = (_k = schema.oneOf) === null || _k === void 0 ? void 0 : _k.map((subschema) => {
+        if ('refIdentifier' in schema) {
+            subschema.isOneOf = schema.refIdentifier;
+        }
+        return reduceToSumOfProducts(subschema, componentSchemas, { _depth: _depth + 1 });
+    });
+    const reducedAnyOfs = (_l = schema.anyOf) === null || _l === void 0 ? void 0 : _l.map((subschema) => {
+        if ('refIdentifier' in schema) {
+            subschema.isAnyOf = schema.refIdentifier;
+        }
+        return reduceToSumOfProducts(subschema, componentSchemas, { _depth: _depth + 1 });
+    });
+    const reducedAllOfs = (_m = schema.allOf) === null || _m === void 0 ? void 0 : _m.map((subschema) => {
+        if ('refIdentifier' in schema) {
+            subschema.isAllOf = schema.refIdentifier;
+        }
+        return reduceToSumOfProducts(subschema, componentSchemas, { _depth: _depth + 1 });
+    });
     const combinedOneOfs = reducedOneOfs ? [addIncrementalSchemas(reducedOneOfs)] : [];
     const combinedAnyOfs = reducedAnyOfs ? [addIncrementalSchemas(reducedAnyOfs)] : [];
     const multipliedAllOfs = reducedAllOfs ? [multiplyIncrementalSchemas(reducedAllOfs)] : [];
-    return multiplyIncrementalSchemas([
+    const result = multiplyIncrementalSchemas([
         ...combinedOneOfs,
         ...combinedAnyOfs,
         ...multipliedAllOfs,
         ...baseSchemaArr,
     ]);
+    // Propagate composition tracking properties to all schemas in the result
+    const resultWithCompositionProps = result.map((product) => product.map((schema) => (Object.assign(Object.assign(Object.assign(Object.assign({}, schema), (schema.isOneOf && { isOneOf: schema.isOneOf })), (schema.isAnyOf && { isAnyOf: schema.isAnyOf })), (schema.isAllOf && { isAllOf: schema.isAllOf })))));
+    return resultWithCompositionProps;
 }
 /**
  * Adds an array of schemas in sum-of-products form, returning the result
@@ -163,7 +187,36 @@ function multiplyIncrementalSchemas(schemas) {
     // in our scenario, the remaining terms are (E + F)(G + H), which gives us (EG + EH + FG + FH)
     const remainingSumOfProducts = multiplyIncrementalSchemas(schemas.slice(1));
     return schemas[0].flatMap((product /* AB */) => {
-        return remainingSumOfProducts.map((remainingProduct /* EF */) => [...product, ...remainingProduct] /* ABEF */);
+        return remainingSumOfProducts.map((remainingProduct /* EF */) => {
+            // Combine all schemas in the product
+            const combinedProduct = [...product, ...remainingProduct];
+            // Propagate composition tracking properties from all schemas to each schema
+            return combinedProduct.map((schema) => {
+                const compositionProps = {};
+                // Collect all composition properties from all schemas in the product
+                combinedProduct.forEach((otherSchema) => {
+                    if (otherSchema.isOneOf)
+                        compositionProps.isOneOf = otherSchema.isOneOf;
+                    if (otherSchema.isAnyOf)
+                        compositionProps.isAnyOf = otherSchema.isAnyOf;
+                    if (otherSchema.isAllOf)
+                        compositionProps.isAllOf = otherSchema.isAllOf;
+                });
+                // Filter out composition properties that match refIdentifier
+                if (schema.refIdentifier) {
+                    if (compositionProps.isOneOf === schema.refIdentifier) {
+                        delete compositionProps.isOneOf;
+                    }
+                    if (compositionProps.isAnyOf === schema.refIdentifier) {
+                        delete compositionProps.isAnyOf;
+                    }
+                    if (compositionProps.isAllOf === schema.refIdentifier) {
+                        delete compositionProps.isAllOf;
+                    }
+                }
+                return Object.assign(Object.assign({}, schema), compositionProps);
+            });
+        });
     });
 }
 /**
@@ -181,183 +234,27 @@ function multiplyIncrementalSchemas(schemas) {
  * @returns A single simple schema that satisfies all the input schemas
  */
 export function combineSimpleSchemas(schemas, componentSchemas, location) {
-    // all schemas with no `type` field go at the end of the array to avoid
-    // caling `copyKeyIfDefined` for discriminators with empty types unless
-    // we're certain the schema's title is the last possible option
-    schemas.sort((a, b) => {
-        var _a, _b;
-        const aDepth = (_a = a._depth) !== null && _a !== void 0 ? _a : 0;
-        const bDepth = (_b = b._depth) !== null && _b !== void 0 ? _b : 0;
-        if (aDepth !== bDepth) {
-            return aDepth - bDepth;
-        }
-        if (a.type && !b.type)
-            return -1;
-        if (!a.type && b.type)
-            return 1;
-        return 0;
-    });
+    sortSchemas(schemas);
     return schemas.reduce((acc, curr) => {
-        var _a, _b, _c, _d, _e, _f;
-        // schemas are meant to be immutable, so copy the type
-        let currType = curr.type;
-        // don't throw an error if type is being constricted
-        if (acc.type === 'integer' && currType === 'number') {
-            currType = 'integer';
-        }
-        else if (acc.type === 'number' && currType === 'integer') {
-            acc.type = 'integer';
-        }
-        else if (acc.type === undefined && currType !== undefined) {
-            acc.type = currType;
-        }
-        else if (acc.type !== undefined && currType === undefined) {
-            currType = acc.type;
-        }
-        if (acc.type !== currType) {
-            throw new Error(`${acc.type} vs ${currType}`);
-        }
-        // we're technically breaking immutability rules here, but it's probably okay because
-        // it will be the same every time - we're just normalizing the maximum/minimum
-        // and exclusiveMaximum/exclusiveMinimum properties
+        var _a;
+        mergeTypes(acc, curr);
         for (const schema of [acc, curr]) {
-            if (typeof schema.exclusiveMaximum === 'number') {
-                if (schema.maximum === undefined || schema.maximum >= schema.exclusiveMaximum) {
-                    schema.maximum = schema.exclusiveMaximum;
-                    schema.exclusiveMaximum = true;
-                }
-                else {
-                    schema.exclusiveMaximum = undefined;
-                }
-            }
-            if (typeof schema.exclusiveMinimum === 'number') {
-                if (schema.minimum === undefined || schema.minimum <= schema.exclusiveMinimum) {
-                    schema.minimum = schema.exclusiveMinimum;
-                    schema.exclusiveMinimum = true;
-                }
-                else {
-                    schema.exclusiveMinimum = undefined;
-                }
-            }
-        }
-        if (curr.discriminator == undefined && (curr.type != undefined || acc.title == undefined)) {
-            copyKeyIfDefined('title', curr, acc);
-        }
-        copyKeyIfDefined('refIdentifier', curr, acc);
-        copyKeyIfDefined('examples', curr, acc);
-        copyKeyIfDefined('format', curr, acc);
-        copyKeyIfDefined('default', curr, acc);
-        copyKeyIfDefined('x-default', curr, acc);
-        copyKeyIfDefined('const', curr, acc);
-        combineKeyIfDefined('multipleOf', curr, acc, lcm);
-        combineKeyIfDefined('maxLength', curr, acc, Math.min);
-        combineKeyIfDefined('minLength', curr, acc, Math.max);
-        combineKeyIfDefined('maxItems', curr, acc, Math.min);
-        combineKeyIfDefined('minItems', curr, acc, Math.max);
-        combineKeyIfDefined('maxProperties', curr, acc, Math.min);
-        combineKeyIfDefined('minProperties', curr, acc, Math.max);
-        combineKeyIfDefined('required', curr, acc, (a, b) => b.concat(a.filter((value) => !b.includes(value))));
-        combineKeyIfDefined('enum', curr, acc, (a, b) => b.filter((value) => a.includes(value)));
-        combineKeyIfDefined('readOnly', curr, acc, (a, b) => a && b);
-        combineKeyIfDefined('writeOnly', curr, acc, (a, b) => a && b);
-        combineKeyIfDefined('deprecated', curr, acc, (a, b) => a || b);
-        const combinedMaximum = combine(curr, acc, 'maximum', Math.min);
-        const combinedMinimum = combine(curr, acc, 'minimum', Math.max);
-        const exclusiveMaximum = (acc.maximum === combinedMaximum ? acc.exclusiveMaximum : undefined) ||
-            (curr.maximum === combinedMaximum ? curr.exclusiveMaximum : undefined);
-        addKeyIfDefined('exclusiveMaximum', exclusiveMaximum, acc);
-        const exclusiveMinimum = (acc.minimum === combinedMinimum ? acc.exclusiveMinimum : undefined) ||
-            (curr.minimum === combinedMinimum ? curr.exclusiveMinimum : undefined);
-        addKeyIfDefined('exclusiveMinimum', exclusiveMinimum, acc);
-        addKeyIfDefined('maximum', combinedMaximum, acc);
-        addKeyIfDefined('minimum', combinedMinimum, acc);
-        // don't use coalesce operator, since null is a valid example
-        const example1 = ((_a = acc.examples) === null || _a === void 0 ? void 0 : _a[0]) !== undefined ? acc.examples[0] : acc.example;
-        const example2 = ((_b = curr.examples) === null || _b === void 0 ? void 0 : _b[0]) !== undefined ? curr.examples[0] : curr.example;
-        if (example1 && example2 && typeof example1 === 'object' && typeof example2 === 'object') {
-            acc.example = Object.assign(Object.assign({}, example1), example2);
-        }
-        else {
-            // don't use coalesce operator, since null is a valid example
-            addKeyIfDefined('example', example2 !== undefined ? example2 : example1, acc);
+            normalizeMinMax(schema);
         }
+        combineTitle(acc, curr);
+        copyAndCombineKeys(acc, curr);
+        combineExamples(acc, curr);
         if (curr.items) {
-            const items = (_c = acc.items) !== null && _c !== void 0 ? _c : { allOf: [] };
+            const items = (_a = acc.items) !== null && _a !== void 0 ? _a : { allOf: [] };
             items.allOf.push(curr.items);
             acc.items = items;
         }
-        if (curr.properties) {
-            Object.entries(curr.properties)
-                .filter(([_, subschema]) => {
-                // dereference just for the readOnly/writeOnly check
-                if ('$ref' in subschema) {
-                    const dereferencedSchema = dereference('schemas', subschema.$ref, componentSchemas);
-                    if (!dereferencedSchema)
-                        return true;
-                    subschema = dereferencedSchema;
-                }
-                if (subschema.readOnly && location === 'request')
-                    return false;
-                if (subschema.writeOnly && location === 'response')
-                    return false;
-                return true;
-            })
-                .forEach(([property, subschema]) => {
-                var _a;
-                const properties = (_a = acc.properties) !== null && _a !== void 0 ? _a : {};
-                const currSchemaArr = properties[property];
-                if (currSchemaArr) {
-                    currSchemaArr.allOf.push(subschema);
-                }
-                else {
-                    properties[property] = { allOf: [subschema] };
-                }
-                acc.properties = properties;
-            });
-        }
-        if (((_d = acc.properties) === null || _d === void 0 ? void 0 : _d.type) && curr.discriminator && !acc.description) {
-            let name = undefined;
-            const allOf = (_e = acc.properties.type.allOf[0]) !== null && _e !== void 0 ? _e : {};
-            if ('const' in allOf && typeof allOf.const === 'string') {
-                name = allOf.const;
-            }
-            const description = recursivelyFindDescription(curr, name) ||
-                schemas.flatMap((schema) => recursivelyFindDescription(schema, name)).filter(Boolean)[0];
-            if (description) {
-                acc.description = description;
-            }
-        }
-        else if (acc.description &&
-            curr.description &&
-            !curr.discriminator &&
-            !acc.description.includes(curr.description)) {
-            acc.description = `${acc.description}\n${curr.description}`;
-        }
-        else if (!acc.description) {
-            copyKeyIfDefined('description', curr, acc);
-        }
-        if (curr.additionalProperties === false) {
-            acc.additionalProperties = false;
-        }
-        else if (acc.additionalProperties !== false &&
-            curr.additionalProperties &&
-            typeof curr.additionalProperties === 'object') {
-            const additionalProperties = (_f = acc.additionalProperties) !== null && _f !== void 0 ? _f : { allOf: [] };
-            additionalProperties.allOf.push(curr.additionalProperties);
-            acc.additionalProperties = additionalProperties;
-        }
+        combineProperties(acc, curr, componentSchemas, location);
+        combineDescription(acc, curr, schemas);
+        combineAdditionalProperties(acc, curr);
         return acc;
     }, {});
 }
-const combineKeyIfDefined = (key, source, destination, transform) => {
-    addKeyIfDefined(key, combine(source, destination, key, transform), destination);
-};
-const combine = (schema1, schema2, key, transform) => {
-    var _a;
-    return schema1[key] !== undefined && schema2[key] !== undefined
-        ? transform(schema1[key], schema2[key])
-        : (_a = schema1[key]) !== null && _a !== void 0 ? _a : schema2[key];
-};
 function convertCombinedSchema(schema, required) {
     var _a, _b;
     const sharedProps = {};

package/dist/openapi/types/endpoint.d.ts

@@ -120,6 +120,9 @@ export type BaseSchema<T> = {
     writeOnly?: boolean;
     deprecated?: boolean;
     refIdentifier?: string;
+    isOneOf?: string;
+    isAnyOf?: string;
+    isAllOf?: string;
 };
 export type BooleanSchema = {
     type: 'boolean';

package/dist/openapi/types/schema.d.ts

@@ -0,0 +1,31 @@
+import { OpenAPIV3_1 } from 'openapi-types';
+export type Schema3_1 = OpenAPIV3_1.SchemaObject;
+export type Ref = OpenAPIV3_1.ReferenceObject;
+export type SchemaOrRef = Schema3_1 | Ref;
+export type ComponentsSection = keyof OpenAPIV3_1.ComponentsObject;
+export type Compositions = 'allOf' | 'oneOf' | 'anyOf' | 'not';
+export type SimpleSchema = Omit<OpenAPIV3_1.SchemaObject, Compositions> & {
+    items?: OpenAPIV3_1.SchemaObject;
+    refIdentifier?: string;
+    _depth?: number;
+    isOneOf?: string;
+    isAnyOf?: string;
+    isAllOf?: string;
+};
+export type SumOfProducts = SimpleSchema[][];
+export type SimpleSchemaWithSubschemas = SimpleSchema & {
+    properties?: Record<string, {
+        allOf: SchemaOrRef[];
+    }>;
+    items?: {
+        allOf: SchemaOrRef[];
+    };
+    additionalProperties?: {
+        allOf: SchemaOrRef[];
+    } | false;
+};
+export type SchemaOrRefComposition = SchemaOrRef & {
+    isOneOf?: string;
+    isAnyOf?: string;
+    isAllOf?: string;
+};

package/dist/openapi/types/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/openapi/utils.d.ts

@@ -1,12 +1,20 @@
 import { OpenAPIV3_1 } from 'openapi-types';
-import { SimpleSchema } from './IncrementalEvaluator.js';
 import { DataSchema } from './types/endpoint.js';
+import { ComponentsSection, Schema3_1, SimpleSchema, SimpleSchemaWithSubschemas } from './types/schema.js';
 export declare const stringFileFormats: string[];
 export declare const structuredDataContentTypes: string[];
-type ComponentsSection = keyof OpenAPIV3_1.ComponentsObject;
 export declare function dereference<S extends ComponentsSection>(section: S, $ref: string, components: Record<string, NonNullable<OpenAPIV3_1.ComponentsObject[S]>[string]> | undefined, maxDepth?: number): NonNullable<OpenAPIV3_1.ComponentsObject[S]>[string] | undefined;
 export declare const addKeyIfDefined: <D, K extends keyof D>(key: K, value: D[K] | undefined, destination: D) => void;
 export declare const copyKeyIfDefined: <D, K extends keyof D>(key: K, source: Pick<D, K>, destination: D) => void;
 export declare const copyExampleIfDefined: (source: Pick<OpenAPIV3_1.SchemaObject, "example" | "examples">, destination: Pick<DataSchema, "example">) => void;
 export declare function recursivelyFindDescription(schema: SimpleSchema, name: string | undefined): string | undefined;
-export {};
+export declare function sortSchemas(schemas: SimpleSchema[]): void;
+export declare function mergeTypes(acc: SimpleSchemaWithSubschemas, curr: SimpleSchema): void;
+export declare function normalizeMinMax(schema: SimpleSchema): void;
+export declare function combineTitle(acc: SimpleSchemaWithSubschemas, curr: SimpleSchema): void;
+export declare function copyAndCombineKeys(acc: SimpleSchemaWithSubschemas, curr: SimpleSchema): void;
+export declare function combineExamples(acc: SimpleSchemaWithSubschemas, curr: SimpleSchema): void;
+export declare function combineProperties(acc: SimpleSchemaWithSubschemas, curr: SimpleSchema, componentSchemas: Record<string, Schema3_1> | undefined, location?: 'request' | 'response'): void;
+export declare function combineDescription(acc: SimpleSchemaWithSubschemas, curr: SimpleSchema, schemas: SimpleSchema[]): void;
+export declare function combineAdditionalProperties(acc: SimpleSchemaWithSubschemas, curr: SimpleSchema): void;
+export declare function discriminatorAndSchemaRefsMatch(schema: SimpleSchema): boolean;