@mintlify/validation 0.1.58 → 0.1.59

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

@@ -231,11 +231,11 @@ export declare const configSchema: z.ZodObject<{
     }, "strict", z.ZodTypeAny, {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
     }, {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
     }>>;
     anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -261,7 +261,7 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -273,7 +273,7 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -521,8 +521,8 @@ export declare const configSchema: z.ZodObject<{
         destination: string;
     }[]>>;
 }, "strip", z.ZodTypeAny, {
-    $schema: string;
     name: string;
+    $schema: string;
     favicon: string;
     colors: {
         primary: string;
@@ -596,13 +596,13 @@ export declare const configSchema: z.ZodObject<{
     topAnchor?: {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
     } | undefined;
     anchors?: {
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -615,10 +615,10 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
     }[] | undefined;
-    footerSocials?: Record<string, string> | {
+    footerSocials?: {
         type: string;
         url: string;
-    }[] | undefined;
+    }[] | Record<string, string> | undefined;
     backgroundImage?: string | undefined;
     feedback?: {
         thumbsRating?: boolean | undefined;
@@ -753,13 +753,13 @@ export declare const configSchema: z.ZodObject<{
     topAnchor?: {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
     } | undefined;
     anchors?: {
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -772,10 +772,10 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
     }[] | undefined;
-    footerSocials?: Record<string, string> | {
+    footerSocials?: {
         type: string;
         url: string;
-    }[] | undefined;
+    }[] | Record<string, string> | undefined;
     backgroundImage?: string | undefined;
     feedback?: {
         thumbsRating?: boolean | undefined;

package/dist/mint-config/schemas/config.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = void 0;
+var zod_1 = require("zod");
+var analytics_1 = require("./analytics");
+var anchors_1 = require("./anchors");
+var apiReference_1 = require("./apiReference");
+var basics_1 = require("./basics");
+var colors_1 = require("./colors");
+var favicon_1 = require("./favicon");
+var integrations_1 = require("./integrations");
+var navigation_1 = require("./navigation");
+var tabs_1 = require("./tabs");
+var versions_1 = require("./versions");
+exports.configSchema = zod_1.z.object({
+    $schema: zod_1.z.string().url().optional().default('https://mintlify.com/schema.json'),
+    mintlify: zod_1.z.string().optional(),
+    name: basics_1.nameSchema,
+    logo: basics_1.logoSchema.optional(),
+    favicon: favicon_1.faviconSchema,
+    openapi: apiReference_1.openApiSchema.optional(),
+    api: apiReference_1.apiSchema.optional(),
+    modeToggle: basics_1.modeToggleSchema.optional(),
+    versions: versions_1.versionsSchema.optional(),
+    metadata: basics_1.metadataSchema.optional(),
+    colors: colors_1.colorsSchema,
+    topbarCtaButton: (0, basics_1.createCtaButtonSchema)('topbarCtaButton').optional(),
+    topbarLinks: zod_1.z.array((0, basics_1.createCtaButtonSchema)('topbarLinks')).optional(),
+    navigation: navigation_1.navigationConfigSchema,
+    primaryTab: tabs_1.primaryTabSchema.optional(),
+    topAnchor: anchors_1.topAnchorSchema.optional(),
+    anchors: anchors_1.anchorsSchema.optional(),
+    tabs: tabs_1.tabsSchema.optional(),
+    footerSocials: basics_1.footerSocialsSchema.optional(),
+    backgroundImage: zod_1.z.string().optional(),
+    feedback: basics_1.feedbackSchema.optional(),
+    analytics: analytics_1.analyticsSchema.optional(),
+    integrations: integrations_1.integrationsSchema.optional(),
+    isWhiteLabeled: basics_1.isWhiteLabeledSchema.optional(),
+    search: basics_1.searchSchema.optional(),
+    redirects: basics_1.redirectsSchema.optional(),
+});

package/dist/mint-config/schemas/favicon.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.faviconSchema = void 0;
+var zod_1 = require("zod");
+exports.faviconSchema = zod_1.z
+    .string({
+    required_error: 'Favicon is missing. Please set favicon to the path of your favicon file. We recommend using a .svg or .png file. Mintlify automatically resizes your favicon to the sizes needed.',
+    invalid_type_error: 'Favicon must be a string path pointing to the favicon file in your Mintlify folder.',
+})
+    .refine(function (val) { return val.split('.').pop() !== 'ico'; }, {
+    message: 'Favicon cannot be an .ico file.',
+});

package/dist/mint-config/schemas/integrations.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrationsSchema = void 0;
+var zod_1 = require("zod");
+var intercomSchema = zod_1.z
+    .string({ invalid_type_error: 'integrations.intercom must be a string' })
+    .min(6, 'integrations.intercom must be a valid Intercom app ID');
+var frontchatSchema = zod_1.z
+    .string({ invalid_type_error: 'integrations.frontchat must be a string' })
+    .min(6, 'integrations.frontchat must be a valid Front chat snippet id');
+exports.integrationsSchema = zod_1.z.object({
+    intercom: intercomSchema.optional(),
+    frontchat: frontchatSchema.optional(),
+}, { invalid_type_error: 'integrations must be an object' });

package/dist/mint-config/schemas/navigation.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.navigationConfigSchema = void 0;
+var zod_1 = require("zod");
+var navigationSchema = zod_1.z.lazy(function () {
+    return zod_1.z
+        .object({
+        // We allow top-level groups to be an empty string if the user wants to hide the title.
+        // Future work should refactor this so nested groups are non-empty strings.
+        group: zod_1.z.string({
+            required_error: 'Missing navigation group name.',
+            invalid_type_error: 'Group must be a string. We use the group name to create the navigation sidebar.',
+        }),
+        pages: zod_1.z
+            .array(zod_1.z.union([navigationSchema, zod_1.z.string().min(1, 'Page cannot be an empty string.')]))
+            .min(1, "Pages array can't be empty."),
+        icon: zod_1.z.string({ invalid_type_error: 'Icon must be a string.' }).optional(),
+        version: zod_1.z.string({ invalid_type_error: 'Version must be a string.' }).optional(),
+    }, { invalid_type_error: 'Navigation entry must be an object.' })
+        .strict('Navigation entry can only contain group, pages, icon, and version.');
+});
+exports.navigationConfigSchema = zod_1.z
+    .array(navigationSchema, {
+    required_error: 'Navigation is missing.',
+    invalid_type_error: 'Navigation must be an array.',
+})
+    .min(1, 'Navigation cannot be an empty array. Please add at least one group.');

package/dist/mint-config/schemas/tabs.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primaryTabSchema = exports.tabsSchema = void 0;
+var zod_1 = require("zod");
+var tabSchema = zod_1.z.object({
+    name: zod_1.z
+        .string({
+        required_error: 'Every tab must have a name.',
+        invalid_type_error: 'Tab name must be a string.',
+    })
+        .trim()
+        .min(1, 'Tab name is empty.'),
+    url: zod_1.z
+        .string({
+        required_error: 'Every tab must have a url',
+        invalid_type_error: 'Tab url must be a string.',
+    })
+        .trim()
+        .min(1, 'Tab URL is missing.'),
+});
+exports.tabsSchema = tabSchema.array();
+exports.primaryTabSchema = zod_1.z
+    .object({
+    name: zod_1.z.string({
+        required_error: 'primaryTab.name is missing, set it or delete the entire primaryTab property.',
+        invalid_type_error: 'primaryTab.name must be a string',
+    }),
+}, {
+    invalid_type_error: 'primaryTab must be an object with a name property.',
+})
+    .strict('primaryTab can only have name properties.');

package/dist/mint-config/schemas/versions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionsSchema = void 0;
+var zod_1 = require("zod");
+var versionSchema = zod_1.z.union([
+    zod_1.z.string({ invalid_type_error: 'Versions must be an array of strings.' }),
+    zod_1.z
+        .object({
+        name: zod_1.z.string().min(1, 'Name cannot be an empty string.'),
+        url: zod_1.z.string().min(1, 'URL cannot be an empty string.'),
+    })
+        .strict('Object must contain name and url properties'),
+]);
+exports.versionsSchema = zod_1.z
+    .array(versionSchema)
+    .min(1, 'Versions array cannot be empty. Either delete the property or add strings to the array.');

package/dist/mint-config/types/enums.js

@@ -0,0 +1,4 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-types */
+// explanation for (string & {}): https://twitter.com/mattpocockuk/status/1671908303918473217?s=20
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mint-config/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mint-config/types/navigation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mint-config/validateAnchorsWarnings.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAnchorsWarnings = void 0;
+var common_1 = require("./common");
+var navigation_1 = require("./schemas/navigation");
+function validateAnchorsWarnings(anchors, navigation) {
+    var results = new common_1.MintValidationResults();
+    if (anchors &&
+        Array.isArray(anchors) &&
+        navigation &&
+        navigation_1.navigationConfigSchema.safeParse(navigation).success === true) {
+        anchors.forEach(function (anchor) {
+            if (!anchor.url.startsWith('mailto:') &&
+                !anchor.url.startsWith('http') &&
+                !anchor.url.startsWith('https') &&
+                !navigation.some(function (nav) { return pageStartsWith(nav, anchor.url); })) {
+                results.warnings.push('No pages in the navigation match anchor ' +
+                    anchor.url +
+                    ' you should have at least one page that starts with ' +
+                    anchor.url);
+            }
+        });
+    }
+    return results;
+}
+exports.validateAnchorsWarnings = validateAnchorsWarnings;
+function pageStartsWith(navEntry, prefix) {
+    if (typeof navEntry === 'string') {
+        return navEntry.startsWith(prefix);
+    }
+    else if (navEntry.pages == undefined) {
+        return false;
+    }
+    else {
+        return navEntry.pages.some(function (entry) {
+            return pageStartsWith(entry, prefix);
+        });
+    }
+}

package/dist/mint-config/validateVersionsInNavigation.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateVersionsInNavigation = exports.flattenNavigationVersions = void 0;
+var common_1 = require("./common");
+var navigation_1 = require("./schemas/navigation");
+function flattenNavigationVersions(nav, versions) {
+    if (versions === void 0) { versions = []; }
+    nav.forEach(function (val) {
+        if (val == null || typeof val === 'string') {
+            return versions;
+        }
+        if (val.version) {
+            versions.push(val.version);
+        }
+        if (!Array.isArray(val.pages)) {
+            return versions;
+        }
+        return flattenNavigationVersions(val.pages, versions);
+    });
+    return versions;
+}
+exports.flattenNavigationVersions = flattenNavigationVersions;
+function validateVersionsInNavigation(navigation, versions) {
+    if (versions === void 0) { versions = []; }
+    var results = new common_1.MintValidationResults();
+    if (navigation == null || navigation_1.navigationConfigSchema.safeParse(navigation).success === false) {
+        return results;
+    }
+    var versionsFromNavigation = flattenNavigationVersions(navigation);
+    versionsFromNavigation.forEach(function (v) {
+        if (versions && !versions.includes(v)) {
+            results.errors.push("Version ".concat(v, " is not included in the versions array, but is used in the navigation. Please add ").concat(v, " to the versions array."));
+        }
+    });
+    if (versionsFromNavigation.length === 0 && versions.length > 0) {
+        results.warnings.push('You have versions defined in the config, but no versions are used in the navigation.');
+    }
+    navigation.forEach(function (nav) {
+        var _a;
+        (_a = results.warnings).push.apply(_a, warnVersionNesting(nav, null));
+    });
+    return results;
+}
+exports.validateVersionsInNavigation = validateVersionsInNavigation;
+function warnVersionNesting(navigation, currentVersion) {
+    if (typeof navigation === 'string') {
+        return [];
+    }
+    var warnings = [];
+    if (navigation.version && currentVersion != null && navigation.version !== currentVersion) {
+        warnings.push("Please do not set versions on groups nested inside a group that already has a version. The group \"".concat(navigation.group, "\" has version \"").concat(navigation.version, "\" set and it is nested in a group that has the version \"").concat(currentVersion, "\" set."));
+    }
+    if (navigation.pages) {
+        return warnings.concat(navigation.pages
+            .map(function (entry) { return warnVersionNesting(entry, currentVersion || navigation.version); })
+            .flat()
+            .filter(Boolean));
+    }
+    return [];
+}

package/dist/openapi/convertOpenApi.js

@@ -0,0 +1,174 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertOpenAPIV3_1ToEndpoint = exports.convertResponse = exports.convertResponses = exports.convertBody = exports.ConversionError = exports.ImpossibleSchemaError = exports.InvalidSchemaError = exports.generateMessage = void 0;
+var convertParameters_1 = require("./convertParameters");
+var convertSchema_1 = require("./convertSchema");
+var convertSecurity_1 = require("./convertSecurity");
+var convertServers_1 = require("./convertServers");
+var generateMessage = function (path, messages) {
+    if (messages === void 0) { messages = []; }
+    var pathString = path
+        .map(function (component) { return component.replace('\\', '\\\\').replace('/', '\\/'); })
+        .join('/');
+    return __spreadArray([pathString], messages, true).join('\n');
+};
+exports.generateMessage = generateMessage;
+var InvalidSchemaError = /** @class */ (function (_super) {
+    __extends(InvalidSchemaError, _super);
+    function InvalidSchemaError(path) {
+        var messages = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            messages[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this, (0, exports.generateMessage)(path, messages)) || this;
+        _this.name = 'InvalidSchemaError';
+        Object.setPrototypeOf(_this, InvalidSchemaError.prototype);
+        return _this;
+    }
+    return InvalidSchemaError;
+}(Error));
+exports.InvalidSchemaError = InvalidSchemaError;
+var ImpossibleSchemaError = /** @class */ (function (_super) {
+    __extends(ImpossibleSchemaError, _super);
+    function ImpossibleSchemaError(path) {
+        var messages = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            messages[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this, (0, exports.generateMessage)(path, messages)) || this;
+        _this.name = 'ImpossibleSchemaError';
+        Object.setPrototypeOf(_this, ImpossibleSchemaError.prototype);
+        return _this;
+    }
+    return ImpossibleSchemaError;
+}(Error));
+exports.ImpossibleSchemaError = ImpossibleSchemaError;
+var ConversionError = /** @class */ (function (_super) {
+    __extends(ConversionError, _super);
+    function ConversionError(path) {
+        var messages = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            messages[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this, (0, exports.generateMessage)(path, messages)) || this;
+        _this.name = 'ConversionError';
+        Object.setPrototypeOf(_this, ConversionError.prototype);
+        return _this;
+    }
+    return ConversionError;
+}(Error));
+exports.ConversionError = ConversionError;
+var convertBody = function (path, body) {
+    if (body === undefined) {
+        return {};
+    }
+    var newEntries = Object.entries(body.content).map(function (_a) {
+        var contentType = _a[0], mediaObject = _a[1];
+        return [
+            contentType,
+            (0, convertSchema_1.convertSchema)(__spreadArray(__spreadArray([], path, true), [contentType, 'schema'], false), mediaObject.schema, body.required),
+        ];
+    });
+    return Object.fromEntries(newEntries);
+};
+exports.convertBody = convertBody;
+var convertResponses = function (path, responses) {
+    var newEntries = Object.entries(responses).map(function (_a) {
+        var statusCode = _a[0], response = _a[1];
+        return [
+            statusCode,
+            (0, exports.convertResponse)(__spreadArray(__spreadArray([], path, true), [statusCode], false), response),
+        ];
+    });
+    return Object.fromEntries(newEntries);
+};
+exports.convertResponses = convertResponses;
+var convertResponse = function (path, response) {
+    if (response.content === undefined) {
+        return {};
+    }
+    var newEntries = Object.entries(response.content).map(function (_a) {
+        var contentType = _a[0], mediaType = _a[1];
+        return [
+            contentType,
+            (0, convertSchema_1.convertSchema)(__spreadArray(__spreadArray([], path, true), ['content', contentType, 'schema'], false), mediaType.schema),
+        ];
+    });
+    return Object.fromEntries(newEntries);
+};
+exports.convertResponse = convertResponse;
+var convertOpenAPIV3_1ToEndpoint = function (spec, path, method) {
+    var _a, _b, _c, _d, _e;
+    var paths = spec.paths;
+    if (paths === undefined) {
+        throw new InvalidSchemaError(['#'], 'paths not defined');
+    }
+    var pathObject = paths[path];
+    if (pathObject === undefined) {
+        throw new InvalidSchemaError(['#', 'paths'], "path not defined: ".concat(path));
+    }
+    var operationObject = pathObject[method];
+    if (operationObject === undefined) {
+        throw new InvalidSchemaError(['#', 'paths', path], "operation does not exist: ".concat(method));
+    }
+    var securityRequirements = (_a = operationObject.security) !== null && _a !== void 0 ? _a : spec.security;
+    var securitySchemes = (_b = spec.components) === null || _b === void 0 ? void 0 : _b.securitySchemes;
+    var security = (0, convertSecurity_1.convertSecurity)({
+        securityRequirements: securityRequirements,
+        securitySchemes: securitySchemes,
+    });
+    var pathParameters = pathObject.parameters;
+    var operationParameters = operationObject.parameters;
+    var parameters = (0, convertParameters_1.convertParameters)({
+        path: ['#', 'paths', path],
+        method: method,
+        pathParameters: pathParameters,
+        operationParameters: operationParameters,
+    });
+    var servers = (0, convertServers_1.convertServers)({
+        servers: (_d = (_c = operationObject.servers) !== null && _c !== void 0 ? _c : pathObject.servers) !== null && _d !== void 0 ? _d : spec.servers,
+    });
+    var description = (_e = operationObject.description) !== null && _e !== void 0 ? _e : pathObject === null || pathObject === void 0 ? void 0 : pathObject.description;
+    var requestBody = operationObject.requestBody;
+    var body = (0, exports.convertBody)(['#', 'paths', path, method, 'requestBody'], requestBody);
+    var deprecated = !!operationObject.deprecated;
+    var response = (0, exports.convertResponses)(['#', 'paths', path, method, 'responses'], operationObject.responses);
+    return {
+        description: description,
+        path: path,
+        method: method,
+        servers: servers,
+        request: {
+            security: security,
+            parameters: parameters,
+            body: body,
+        },
+        response: response,
+        deprecated: deprecated,
+    };
+};
+exports.convertOpenAPIV3_1ToEndpoint = convertOpenAPIV3_1ToEndpoint;

package/dist/openapi/convertParameters.js

@@ -0,0 +1,64 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertParameters = void 0;
+var convertOpenApi_1 = require("./convertOpenApi");
+var convertSchema_1 = require("./convertSchema");
+var convertParameters = function (_a) {
+    var path = _a.path, method = _a.method, pathParameters = _a.pathParameters, operationParameters = _a.operationParameters;
+    var parameterSections = {
+        path: {},
+        query: {},
+        header: {},
+        cookie: {},
+    };
+    pathParameters === null || pathParameters === void 0 ? void 0 : pathParameters.forEach(function (parameterObject, i) {
+        addParameter({
+            path: __spreadArray(__spreadArray([], path, true), ['parameters', i.toString()], false),
+            parameter: parameterObject,
+            parameterSections: parameterSections,
+        });
+    });
+    operationParameters === null || operationParameters === void 0 ? void 0 : operationParameters.forEach(function (parameterObject, i) {
+        addParameter({
+            path: __spreadArray(__spreadArray([], path, true), [method, 'parameters', i.toString()], false),
+            parameter: parameterObject,
+            parameterSections: parameterSections,
+        });
+    });
+    return parameterSections;
+};
+exports.convertParameters = convertParameters;
+var addParameter = function (_a) {
+    var path = _a.path, parameter = _a.parameter, parameterSections = _a.parameterSections;
+    if (!['path', 'header', 'query', 'cookie'].includes(parameter.in)) {
+        throw new convertOpenApi_1.InvalidSchemaError(path, "invalid parameter location: '".concat(parameter.in, "'"));
+    }
+    var location = parameter.in;
+    if (location === 'path') {
+        var newParameter = {
+            required: true,
+            schema: (0, convertSchema_1.convertSchema)(__spreadArray(__spreadArray([], path, true), ['schema'], false), parameter.schema, true),
+        };
+        (0, convertSchema_1.copyKeyIfDefined)('description', parameter, newParameter);
+        (0, convertSchema_1.copyKeyIfDefined)('deprecated', parameter, newParameter);
+        parameterSections.path[parameter.name] = newParameter;
+    }
+    else {
+        var newParameter = {
+            schema: (0, convertSchema_1.convertSchema)(__spreadArray(__spreadArray([], path, true), ['schema'], false), parameter.schema, true),
+        };
+        (0, convertSchema_1.copyKeyIfDefined)('description', parameter, newParameter);
+        (0, convertSchema_1.copyKeyIfDefined)('deprecated', parameter, newParameter);
+        (0, convertSchema_1.copyKeyIfDefined)('required', parameter, newParameter);
+        parameterSections[location][parameter.name] = newParameter;
+    }
+};