@mintlify/validation 0.1.98 → 0.1.100

package/dist/openapi/convertOpenApi.js

@@ -1,118 +0,0 @@
-import { convertParameters } from './convertParameters.js';
-import { convertSchema } from './convertSchema.js';
-import { convertSecurity } from './convertSecurity.js';
-import { convertServers } from './convertServers.js';
-import { generateExampleFromSchema } from './generateExampleFromSchema.js';
-export const generateMessage = (path, messages = []) => {
-    const pathString = path
-        .map((component) => component.replace('\\', '\\\\').replace('/', '\\/'))
-        .join('/');
-    return [pathString, ...messages].join('\n');
-};
-export class InvalidSchemaError extends Error {
-    constructor(path, ...messages) {
-        super(generateMessage(path, messages));
-        this.name = 'InvalidSchemaError';
-        Object.setPrototypeOf(this, InvalidSchemaError.prototype);
-    }
-}
-export class ImpossibleSchemaError extends Error {
-    constructor(path, ...messages) {
-        super(generateMessage(path, messages));
-        this.name = 'ImpossibleSchemaError';
-        Object.setPrototypeOf(this, ImpossibleSchemaError.prototype);
-    }
-}
-export class ConversionError extends Error {
-    constructor(path, ...messages) {
-        super(generateMessage(path, messages));
-        this.name = 'ConversionError';
-        Object.setPrototypeOf(this, ConversionError.prototype);
-    }
-}
-export const convertContent = (path, content, required) => {
-    if (content === undefined) {
-        return {};
-    }
-    const newEntries = Object.entries(content).map(([contentType, mediaObject]) => {
-        const schemaArray = convertSchema([...path, contentType, 'schema'], mediaObject.schema, required);
-        const examples = convertExamples(mediaObject.examples, mediaObject.example, schemaArray);
-        return [contentType, { schemaArray, examples }];
-    });
-    return Object.fromEntries(newEntries);
-};
-export const convertExamples = (examples, example, schemaArray) => {
-    if (examples && Object.values(examples).some(({ value }) => value !== undefined)) {
-        return Object.fromEntries(Object.entries(examples)
-            .filter(([_, { value }]) => value !== undefined)
-            .map(([key, example]) => [
-            key,
-            {
-                summary: example.summary,
-                description: example.description,
-                value: example.value,
-            },
-        ]));
-    }
-    if (example !== undefined) {
-        return { example: { value: example } };
-    }
-    return { example: { value: generateExampleFromSchema(schemaArray[0]) } };
-};
-export const convertResponses = (path, responses) => {
-    const newEntries = Object.entries(responses).map(([statusCode, response]) => [
-        statusCode,
-        convertContent([...path, statusCode, 'content'], response.content),
-    ]);
-    return Object.fromEntries(newEntries);
-};
-export const convertOpenAPIV3_1ToEndpoint = (spec, path, method) => {
-    var _a, _b, _c, _d, _e;
-    const paths = spec.paths;
-    if (paths === undefined) {
-        throw new InvalidSchemaError(['#'], 'paths not defined');
-    }
-    const pathObject = paths[path];
-    if (pathObject === undefined) {
-        throw new InvalidSchemaError(['#', 'paths'], `path not defined: ${path}`);
-    }
-    const operationObject = pathObject[method];
-    if (operationObject === undefined) {
-        throw new InvalidSchemaError(['#', 'paths', path], `operation does not exist: ${method}`);
-    }
-    const securityRequirements = (_a = operationObject.security) !== null && _a !== void 0 ? _a : spec.security;
-    const securitySchemes = (_b = spec.components) === null || _b === void 0 ? void 0 : _b.securitySchemes;
-    const security = convertSecurity({
-        securityRequirements,
-        securitySchemes,
-    });
-    const pathParameters = pathObject.parameters;
-    const operationParameters = operationObject.parameters;
-    const parameters = convertParameters({
-        path: ['#', 'paths', path],
-        method,
-        pathParameters: pathParameters,
-        operationParameters: operationParameters,
-    });
-    const servers = convertServers({
-        servers: (_d = (_c = operationObject.servers) !== null && _c !== void 0 ? _c : pathObject.servers) !== null && _d !== void 0 ? _d : spec.servers,
-    });
-    const description = (_e = operationObject.description) !== null && _e !== void 0 ? _e : pathObject === null || pathObject === void 0 ? void 0 : pathObject.description;
-    const requestBody = operationObject.requestBody;
-    const body = convertContent(['#', 'paths', path, method, 'requestBody', 'content'], requestBody === null || requestBody === void 0 ? void 0 : requestBody.content, requestBody === null || requestBody === void 0 ? void 0 : requestBody.required);
-    const deprecated = !!operationObject.deprecated;
-    const response = convertResponses(['#', 'paths', path, method, 'responses'], operationObject.responses);
-    return {
-        description,
-        path,
-        method,
-        servers,
-        request: {
-            security,
-            parameters,
-            body,
-        },
-        response,
-        deprecated,
-    };
-};

package/dist/openapi/convertParameters.d.ts

@@ -1,9 +0,0 @@
-import { OpenAPIV3_1 } from 'openapi-types';
-import { ParameterSections } from './types/endpoint.js';
-export type ConvertParametersParams = {
-    path: string[];
-    method: string;
-    pathParameters: OpenAPIV3_1.ParameterObject[] | undefined;
-    operationParameters: OpenAPIV3_1.ParameterObject[] | undefined;
-};
-export declare const convertParameters: ({ path, method, pathParameters, operationParameters, }: ConvertParametersParams) => ParameterSections;

package/dist/openapi/convertParameters.js

@@ -1,37 +0,0 @@
-import { InvalidSchemaError } from './convertOpenApi.js';
-import { convertSchema, copyKeyIfDefined } from './convertSchema.js';
-export const convertParameters = ({ path, method, pathParameters, operationParameters, }) => {
-    const parameterSections = {
-        path: {},
-        query: {},
-        header: {},
-        cookie: {},
-    };
-    pathParameters === null || pathParameters === void 0 ? void 0 : pathParameters.forEach((parameterObject, i) => {
-        addParameter({
-            path: [...path, 'parameters', i.toString()],
-            parameter: parameterObject,
-            parameterSections,
-        });
-    });
-    operationParameters === null || operationParameters === void 0 ? void 0 : operationParameters.forEach((parameterObject, i) => {
-        addParameter({
-            path: [...path, method, 'parameters', i.toString()],
-            parameter: parameterObject,
-            parameterSections,
-        });
-    });
-    return parameterSections;
-};
-const addParameter = ({ path, parameter, parameterSections }) => {
-    if (!['path', 'header', 'query', 'cookie'].includes(parameter.in)) {
-        throw new InvalidSchemaError(path, `invalid parameter location: '${parameter.in}'`);
-    }
-    const location = parameter.in;
-    // parameter.schema may be undefined (if the schema is instead defined in parameter.content), but this is likely super rare
-    const parameterSchema = parameter.schema;
-    copyKeyIfDefined('description', parameter, parameterSchema);
-    copyKeyIfDefined('deprecated', parameter, parameterSchema);
-    const newParameter = convertSchema([...path, 'schema'], parameter.schema, location === 'path' ? true : parameter.required);
-    parameterSections[location][parameter.name] = { schema: newParameter };
-};

package/dist/openapi/convertSchema.d.ts

@@ -1,11 +0,0 @@
-import { OpenAPIV3_1 } from 'openapi-types';
-import { DataSchemaArray } from './types/endpoint.js';
-export declare const convertSchema: (path: string[], schema: OpenAPIV3_1.SchemaObject | undefined, required?: boolean) => DataSchemaArray;
-export declare const combineTopLevelSchemas: (path: string[], schema1: OpenAPIV3_1.SchemaObject, schema2: OpenAPIV3_1.SchemaObject) => OpenAPIV3_1.SchemaObject;
-export declare const addKeyIfDefined: <D, K extends keyof D>(key: K, value: D[K], destination: D) => void;
-export declare const copyKeyIfDefined: <D, K extends keyof D>(key: K, source: Pick<D, K>, destination: D) => void;
-export declare const convertProperties: (path: string[], properties: {
-    [key: string]: OpenAPIV3_1.SchemaObject;
-} | undefined, required?: string[]) => {
-    [key: string]: DataSchemaArray;
-};

package/dist/openapi/convertSchema.js

@@ -1,462 +0,0 @@
-import lcm from 'lcm';
-import _ from 'lodash';
-import { ConversionError, ImpossibleSchemaError, InvalidSchemaError } from './convertOpenApi.js';
-import { typeList, } from './types/endpoint.js';
-export const convertSchema = (path, schema, required) => {
-    if (schema === undefined) {
-        throw new InvalidSchemaError(path, 'schema undefined');
-    }
-    // TODO(ronan): remove when fully migrated to endpoint type, or don't modify schema in evaluateCompositionsRecursive
-    schema = _.cloneDeep(schema);
-    schema = evaluateCompositionsRecursive(path, schema);
-    return convertSchemaRecursive(path, schema, required);
-};
-/**
- * This function should be used to reduce strictly `oneOf` and `anyOf` compositions.
- *
- * @param schemaArray `schema.allOf` or `schema.oneOf`
- * @returns a schema array equivalent to the `schemaArray` argument, but in reduced form
- */
-const evaluateOptionsCompositions = (path, schemaArray) => {
-    const evaluatedArray = schemaArray.flatMap((subschema, i) => {
-        var _a;
-        try {
-            return (_a = evaluateCompositionsRecursive([...path, i.toString()], subschema).oneOf) !== null && _a !== void 0 ? _a : [];
-        }
-        catch (error) {
-            if (error instanceof ImpossibleSchemaError) {
-                return [];
-            }
-            else {
-                throw error;
-            }
-        }
-    });
-    if (evaluatedArray.length === 0) {
-        throw new ImpossibleSchemaError(path, 'no valid options in schema:', JSON.stringify(schemaArray, undefined, 2));
-    }
-    return evaluatedArray;
-};
-const evaluateCompositionsRecursive = (path, schema) => {
-    // evaluate compositions first; we are currently ignoring `not`
-    if (schema.oneOf && schema.oneOf.length > 0) {
-        schema.oneOf = evaluateOptionsCompositions([...path, 'oneOf'], schema.oneOf);
-    }
-    else {
-        schema.oneOf = [];
-    }
-    if (schema.anyOf && schema.anyOf.length > 0) {
-        schema.anyOf = evaluateOptionsCompositions([...path, 'anyOf'], schema.anyOf);
-    }
-    if (schema.allOf && schema.allOf.length > 0) {
-        const totalAllOfObj = schema.allOf
-            .map((subschema, i) => evaluateCompositionsRecursive([...path, 'allOf', i.toString()], subschema))
-            .reduce((schema1, schema2, i) => combineReducedSchemas([...path, 'allOf', i.toString()], schema1, schema2), {
-            oneOf: [],
-        });
-        schema.oneOf = multiplySchemaArrays(path, schema.oneOf, totalAllOfObj.oneOf);
-    }
-    // evaluate subschemas, if present
-    if (schema.properties) {
-        for (const key in schema.properties) {
-            schema.properties[key] = evaluateCompositionsRecursive([...path, 'properties', key], schema.properties[key]);
-        }
-    }
-    if (schema.items) {
-        schema.items = evaluateCompositionsRecursive([...path, 'items'], schema.items);
-    }
-    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-        try {
-            schema.additionalProperties = evaluateCompositionsRecursive([...path, 'additionalProperties'], schema.additionalProperties);
-        }
-        catch (error) {
-            if (error instanceof ImpossibleSchemaError) {
-                // if additionalProperties schema is impossible, rather than error, just disallow additionalProperties
-                schema.additionalProperties = false;
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    if (schema.anyOf && schema.anyOf.length > 0) {
-        schema.oneOf = multiplySchemaArrays(path, schema.oneOf, schema.anyOf);
-    }
-    const topLevelSchemaArray = generateTopLevelSchemaArray(schema);
-    return { oneOf: multiplySchemaArrays(path, schema.oneOf, topLevelSchemaArray) };
-};
-const generateTopLevelSchemaArray = (schema) => {
-    if (schema.nullable) {
-        const typedSchema = Object.assign({}, schema);
-        delete typedSchema.oneOf;
-        delete typedSchema.nullable;
-        const nullSchema = Object.assign({}, schema);
-        delete nullSchema.oneOf;
-        delete nullSchema.nullable;
-        nullSchema.type = 'null';
-        return [typedSchema, nullSchema];
-    }
-    if (Array.isArray(schema.type)) {
-        if (schema.type.length === 0) {
-            const topLevelSchema = Object.assign({}, schema);
-            delete topLevelSchema.oneOf;
-            delete topLevelSchema.type;
-            return [topLevelSchema];
-        }
-        return schema.type.map((typeString) => {
-            const topLevelSchema = Object.assign({}, schema);
-            delete topLevelSchema.oneOf;
-            topLevelSchema.type = typeString;
-            return topLevelSchema;
-        });
-    }
-    const topLevelSchema = Object.assign({}, schema);
-    delete topLevelSchema.oneOf;
-    return [topLevelSchema];
-};
-/**
- * Given two arrays representing schema options, return an array representing schema options that satisfy one element in both arrays.
- *
- * It is helpful to think of each array as a union of all the schemas in the array. This function can then be thought of as taking
- * the intersection of the two union types.
- *
- * @param a first array of schema options
- * @param b second array of schema options
- * @returns array of schemas that satisfy both arrays
- */
-const multiplySchemaArrays = (path, a, b) => {
-    if (a.length === 0 && b.length === 0) {
-        return [{}];
-    }
-    if (a.length === 0) {
-        return b;
-    }
-    if (b.length === 0) {
-        return a;
-    }
-    const product = a.flatMap((schema1) => {
-        return b.flatMap((schema2) => {
-            try {
-                const combinedSchema = combineTopLevelSchemas(path, schema1, schema2);
-                return [combinedSchema];
-            }
-            catch (error) {
-                if (error instanceof ImpossibleSchemaError) {
-                    return [];
-                }
-                else {
-                    throw error;
-                }
-            }
-        });
-    });
-    if (product.length === 0) {
-        throw new ImpossibleSchemaError(path, 'impossible schema combination:', 'schema array 1:', JSON.stringify(a, undefined, 2), 'schema array 2:', JSON.stringify(b, undefined, 2));
-    }
-    return product;
-};
-const combineReducedSchemas = (path, schema1, schema2) => {
-    var _a, _b;
-    return {
-        oneOf: multiplySchemaArrays(path, ((_a = schema1.oneOf) !== null && _a !== void 0 ? _a : []), ((_b = schema2.oneOf) !== null && _b !== void 0 ? _b : [])),
-    };
-};
-export const combineTopLevelSchemas = (path, schema1, schema2) => {
-    var _a, _b, _c, _d;
-    let type1 = schema1.type;
-    let type2 = schema2.type;
-    // don't throw an error if number type is being constricted
-    if (type1 === 'integer' && type2 === 'number') {
-        type2 = 'integer';
-    }
-    else if (type1 === 'number' && type2 === 'integer') {
-        type1 = 'integer';
-    }
-    if (type1 && type2 && type1 !== type2) {
-        throw new ImpossibleSchemaError(path, `mismatched type in composition: "${type1}" "${type2}"`);
-    }
-    for (const schema of [schema1, schema2]) {
-        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;
-            }
-        }
-    }
-    const combinedSchema = {
-        title: takeLast(schema1, schema2, 'title'),
-        description: takeLast(schema1, schema2, 'description'),
-        format: takeLast(schema1, schema2, 'format'),
-        multipleOf: combine(schema1, schema2, 'multipleOf', lcm),
-        maximum: combine(schema1, schema2, 'maximum', Math.min),
-        minimum: combine(schema1, schema2, 'minimum', Math.max),
-        maxLength: combine(schema1, schema2, 'maxLength', Math.min),
-        minLength: combine(schema1, schema2, 'minLength', Math.max),
-        maxItems: combine(schema1, schema2, 'maxItems', Math.min),
-        minItems: combine(schema1, schema2, 'minItems', Math.max),
-        maxProperties: combine(schema1, schema2, 'maxProperties', Math.min),
-        minProperties: combine(schema1, schema2, 'minProperties', Math.max),
-        required: combine(schema1, schema2, 'required', (a, b) => b.concat(a.filter((value) => !b.includes(value)))),
-        enum: combine(schema1, schema2, 'enum', (a, b) => b.filter((value) => a.includes(value))),
-        readOnly: schema1.readOnly && schema2.readOnly,
-        writeOnly: schema1.writeOnly && schema2.writeOnly,
-        deprecated: schema1.deprecated && schema2.deprecated,
-    };
-    combinedSchema.exclusiveMaximum =
-        (schema1.maximum === combinedSchema.maximum ? schema1.exclusiveMaximum : undefined) ||
-            (schema2.maximum === combinedSchema.maximum ? schema2.exclusiveMaximum : undefined);
-    combinedSchema.exclusiveMinimum =
-        (schema1.minimum === combinedSchema.minimum ? schema1.exclusiveMinimum : undefined) ||
-            (schema2.minimum === combinedSchema.minimum ? schema2.exclusiveMinimum : undefined);
-    // don't use coalesce operator, since null is a valid example
-    const example1 = ((_a = schema1.examples) === null || _a === void 0 ? void 0 : _a[0]) !== undefined ? schema1.examples[0] : schema1.example;
-    const example2 = ((_b = schema2.examples) === null || _b === void 0 ? void 0 : _b[0]) !== undefined ? schema2.examples[0] : schema2.example;
-    if (example1 && example2 && typeof example1 === 'object' && typeof example2 === 'object') {
-        combinedSchema.example = Object.assign(Object.assign({}, example1), example2);
-    }
-    else {
-        // don't use coalesce operator, since null is a valid example
-        combinedSchema.example = example2 !== undefined ? example2 : example1;
-    }
-    const type = type1 !== null && type1 !== void 0 ? type1 : type2;
-    if (type === 'array') {
-        return Object.assign({ type, items: combineReducedSchemas([...path, 'items'], (_c = schema1.items) !== null && _c !== void 0 ? _c : {}, (_d = schema2.items) !== null && _d !== void 0 ? _d : {}) }, combinedSchema);
-    }
-    if (schema1.properties && schema2.properties) {
-        const combinedProperties = Object.assign({}, schema1.properties);
-        Object.entries(schema2.properties).forEach(([property, schema]) => {
-            const schema1Property = combinedProperties[property];
-            if (schema1Property) {
-                combinedProperties[property] = combineReducedSchemas([...path, 'properties', property], schema1Property, schema);
-            }
-            else {
-                combinedProperties[property] = schema;
-            }
-        });
-        combinedSchema.properties = combinedProperties;
-    }
-    else if (schema1.properties || schema2.properties) {
-        combinedSchema.properties = Object.assign(Object.assign({}, schema1.properties), schema2.properties);
-    }
-    if (schema1.additionalProperties === false || schema2.additionalProperties === false) {
-        combinedSchema.additionalProperties = false;
-    }
-    else if (schema1.additionalProperties &&
-        typeof schema1.additionalProperties === 'object' &&
-        schema2.additionalProperties &&
-        typeof schema2.additionalProperties === 'object') {
-        combinedSchema.additionalProperties = combineReducedSchemas([...path, 'additionalProperties'], schema1.additionalProperties, schema2.additionalProperties);
-    }
-    else if (schema1.additionalProperties && typeof schema1.additionalProperties === 'object') {
-        combinedSchema.additionalProperties = schema1.additionalProperties;
-    }
-    else if (schema2.additionalProperties && typeof schema2.additionalProperties === 'object') {
-        combinedSchema.additionalProperties = schema2.additionalProperties;
-    }
-    return Object.assign({ type }, combinedSchema);
-};
-export const addKeyIfDefined = (key, value, destination) => {
-    if (value !== undefined) {
-        destination[key] = value;
-    }
-};
-export const copyKeyIfDefined = (key, source, destination) => {
-    if (source[key] !== undefined) {
-        destination[key] = source[key];
-    }
-};
-const copyExampleIfDefined = (source, destination) => {
-    var _a;
-    const example = ((_a = source.examples) === null || _a === void 0 ? void 0 : _a[0]) !== undefined ? source.examples[0] : source.example;
-    if (example !== undefined) {
-        destination.example = example;
-    }
-};
-const takeLast = (schema1, schema2, key) => {
-    var _a;
-    return (_a = schema2[key]) !== null && _a !== void 0 ? _a : schema1[key];
-};
-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];
-};
-const convertSchemaRecursive = (path, schema, required) => {
-    if (schema.oneOf === undefined || schema.oneOf.length === 0) {
-        throw new ConversionError(path, 'missing schema definition');
-    }
-    const schemaArray = schema.oneOf.map((schema) => {
-        const sharedProps = {};
-        addKeyIfDefined('required', required, sharedProps);
-        copyKeyIfDefined('title', schema, sharedProps);
-        copyKeyIfDefined('description', schema, sharedProps);
-        copyKeyIfDefined('readOnly', schema, sharedProps);
-        copyKeyIfDefined('writeOnly', schema, sharedProps);
-        copyKeyIfDefined('deprecated', schema, sharedProps);
-        if (schema.type === undefined) {
-            const inferredType = inferType(schema);
-            if (inferredType === undefined) {
-                return Object.assign({ type: 'any' }, sharedProps);
-            }
-            schema.type = inferredType;
-        }
-        const type = schema.type;
-        if (!typeList.includes(type)) {
-            throw new InvalidSchemaError(path, `invalid schema type: ${schema.type}`);
-        }
-        switch (schema.type) {
-            case 'boolean':
-                const booleanProps = sharedProps;
-                copyKeyIfDefined('default', schema, booleanProps);
-                copyExampleIfDefined(schema, booleanProps);
-                return Object.assign({ type: schema.type }, booleanProps);
-            case 'number':
-            case 'integer':
-                if (schema.enum) {
-                    const numberEnumProps = sharedProps;
-                    copyKeyIfDefined('default', schema, numberEnumProps);
-                    copyExampleIfDefined(schema, numberEnumProps);
-                    return Object.assign({ type: schema.type === 'number' ? 'enum<number>' : 'enum<integer>', enum: schema.enum }, numberEnumProps);
-                }
-                const numberProps = sharedProps;
-                copyKeyIfDefined('multipleOf', schema, numberProps);
-                copyKeyIfDefined('maximum', schema, numberProps);
-                copyKeyIfDefined('exclusiveMaximum', schema, numberProps);
-                copyKeyIfDefined('minimum', schema, numberProps);
-                copyKeyIfDefined('exclusiveMinimum', schema, numberProps);
-                copyKeyIfDefined('default', schema, numberProps);
-                copyExampleIfDefined(schema, numberProps);
-                return Object.assign({ type: schema.type }, numberProps);
-            case 'string':
-                if (schema.enum) {
-                    const stringEnumProps = sharedProps;
-                    copyKeyIfDefined('default', schema, stringEnumProps);
-                    copyExampleIfDefined(schema, stringEnumProps);
-                    return Object.assign({ type: 'enum<string>', enum: schema.enum }, stringEnumProps);
-                }
-                const stringProps = sharedProps;
-                copyKeyIfDefined('format', schema, stringProps);
-                copyKeyIfDefined('pattern', schema, stringProps);
-                copyKeyIfDefined('maxLength', schema, stringProps);
-                copyKeyIfDefined('minLength', schema, stringProps);
-                copyKeyIfDefined('default', schema, stringProps);
-                copyExampleIfDefined(schema, stringProps);
-                return Object.assign({ type: schema.type }, stringProps);
-            case 'array':
-                const arrayProps = sharedProps;
-                const items = typeof schema.items === 'object' && schema.items != null
-                    ? convertSchemaRecursive([...path, 'items'], schema.items)
-                    : [{ type: 'any' }];
-                copyKeyIfDefined('maxItems', schema, arrayProps);
-                copyKeyIfDefined('minItems', schema, arrayProps);
-                copyKeyIfDefined('uniqueItems', schema, arrayProps);
-                copyKeyIfDefined('default', schema, arrayProps);
-                copyExampleIfDefined(schema, arrayProps);
-                return Object.assign({ type: schema.type, items }, arrayProps);
-            case 'object':
-                const properties = convertProperties([...path, 'properties'], schema.properties, schema.required);
-                const additionalProperties = typeof schema.additionalProperties === 'object' && schema.additionalProperties != null
-                    ? convertSchemaRecursive([...path, 'additionalProperties'], schema.additionalProperties)
-                    : schema.additionalProperties;
-                const objectProperties = sharedProps;
-                addKeyIfDefined('additionalProperties', additionalProperties, objectProperties);
-                copyKeyIfDefined('maxProperties', schema, objectProperties);
-                copyKeyIfDefined('minProperties', schema, objectProperties);
-                copyKeyIfDefined('default', schema, objectProperties);
-                copyExampleIfDefined(schema, objectProperties);
-                return Object.assign({ type: schema.type, properties }, objectProperties);
-            case 'null':
-                const nullProps = sharedProps;
-                copyKeyIfDefined('default', schema, nullProps);
-                copyExampleIfDefined(schema, nullProps);
-                return Object.assign({ type: schema.type }, nullProps);
-            default:
-                throw new ImpossibleSchemaError(path, `impossible type reached: ${schema.type}`);
-        }
-    });
-    if (!schemaArray[0]) {
-        throw new ConversionError(path, 'missing schema definition in position 0');
-    }
-    // must unpack first element to satisfy type
-    return [schemaArray[0], ...schemaArray.slice(1)];
-};
-export const convertProperties = (path, properties, required) => {
-    if (properties === undefined) {
-        return {};
-    }
-    const newEntries = Object.entries(properties).map(([name, schema]) => {
-        return [
-            name,
-            convertSchemaRecursive([...path, name], schema, (required === null || required === void 0 ? void 0 : required.includes(name)) ? true : undefined),
-        ];
-    });
-    return Object.fromEntries(newEntries);
-};
-/**
- * Given an OpenAPI 3.1 schema, this function will attempt to determine the schema type
- * based on the properties present in the schema. This is useful for assigning types to
- * schemas that are missing a type.
- *
- * For example, if a schema has no type but has `schema.properties`, we can infer the
- * intended type is `object`.
- *
- * @param schema
- * @returns if exactly one type can be inferred, the string corresponding to that type; otherwise `undefined`
- */
-const inferType = (schema) => {
-    var _a, _b;
-    let type = undefined;
-    if (schema.format !== undefined ||
-        schema.pattern !== undefined ||
-        schema.minLength !== undefined ||
-        schema.maxLength !== undefined ||
-        ((_a = schema.enum) === null || _a === void 0 ? void 0 : _a.every((option) => typeof option === 'string'))) {
-        if (type !== undefined) {
-            return undefined;
-        }
-        type = 'string';
-    }
-    if (schema.multipleOf !== undefined ||
-        schema.minimum !== undefined ||
-        schema.maximum !== undefined ||
-        schema.exclusiveMinimum !== undefined ||
-        schema.exclusiveMaximum !== undefined ||
-        ((_b = schema.enum) === null || _b === void 0 ? void 0 : _b.every((option) => typeof option === 'number'))) {
-        if (type !== undefined) {
-            return undefined;
-        }
-        type = 'number'; // less specific than 'integer'
-    }
-    if (schema.items !== undefined ||
-        schema.minItems !== undefined ||
-        schema.maxItems !== undefined ||
-        schema.uniqueItems !== undefined) {
-        if (type !== undefined) {
-            return undefined;
-        }
-        type = 'array';
-    }
-    if (schema.additionalProperties !== undefined ||
-        schema.properties !== undefined ||
-        schema.minProperties !== undefined ||
-        schema.maxProperties !== undefined) {
-        if (type !== undefined) {
-            return undefined;
-        }
-        type = 'object';
-    }
-    return type;
-};

package/dist/openapi/convertSecurity.d.ts

@@ -1,14 +0,0 @@
-import { OpenAPIV3_1 } from 'openapi-types';
-import { SecurityOption, SecurityParameterSections } from './types/endpoint.js';
-type ConvertSecurityParams = {
-    securityRequirements?: OpenAPIV3_1.SecurityRequirementObject[];
-    securitySchemes: OpenAPIV3_1.ComponentsObject['securitySchemes'];
-};
-export declare const convertSecurity: ({ securityRequirements, securitySchemes, }: ConvertSecurityParams) => SecurityOption[];
-type AddSecurityParametersParams = {
-    securityName: string;
-    securityScheme: OpenAPIV3_1.SecuritySchemeObject;
-    parameterSections: SecurityParameterSections;
-};
-export declare const addSecurityParameters: ({ securityName, securityScheme, parameterSections, }: AddSecurityParametersParams) => void;
-export {};