docusaurus-plugin-openapi-docs 4.7.1 → 5.0.0

package/README.md

@@ -41,9 +41,10 @@ Key Features:
 
 | Docusaurus OpenAPI Docs | Docusaurus      |
 | ----------------------- | --------------- |
-| 4.x.x (current)         | `3.5.0 - 3.9.2` |
+| 5.x.x (current)         | `3.10.0+`       |
+| 4.x.x (legacy)          | `3.5.0 - 3.9.2` |
 | 3.0.x (end-of-support)  | `3.0.1 - 3.4.0` |
-| 2.2.3 (legacy)          | `2.4.1 - 2.4.3` |
+| 2.2.3 (end-of-support)  | `2.4.1 - 2.4.3` |
 | 1.7.3 (end-of-support)  | `2.0.1 - 2.2.0` |
 
 ## Bootstrapping from Template (new Docusaurus site)
@@ -51,7 +52,7 @@ Key Features:
 Run the following to bootstrap a Docusaurus v3 site (classic theme) with `docusaurus-openapi-docs`:
 
 ```bash
-npx create-docusaurus@3.9.2 my-website --package-manager yarn
+npx create-docusaurus@3.10.0 my-website --package-manager yarn
 ```
 
 > When prompted to select a template choose `Git repository`.
@@ -253,11 +254,12 @@ petstore: {
 
 The `docusaurus-theme-openapi-docs` theme can be configured with the following options in `themeConfig.api`:
 
-| Name              | Type     | Default | Description                                                                                                                        |
-| ----------------- | -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| `proxy`           | `string` | `null`  | _Optional:_ Site-wide proxy URL to prepend to base URL when performing API requests. Can be overridden per-spec via plugin config. |
-| `authPersistance` | `string` | `null`  | _Optional:_ Determines how auth credentials are persisted. Options: `"localStorage"`, `"sessionStorage"`, or `false` to disable.   |
-| `requestTimeout`  | `number` | `30000` | _Optional:_ Request timeout in milliseconds for API requests made from the browser. Defaults to 30 seconds.                        |
+| Name                 | Type     | Default         | Description                                                                                                                        |
+| -------------------- | -------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `proxy`              | `string` | `null`          | _Optional:_ Site-wide proxy URL to prepend to base URL when performing API requests. Can be overridden per-spec via plugin config. |
+| `authPersistance`    | `string` | `null`          | _Optional:_ Determines how auth credentials are persisted. Options: `"localStorage"`, `"sessionStorage"`, or `false` to disable.   |
+| `requestTimeout`     | `number` | `30000`         | _Optional:_ Request timeout in milliseconds for API requests made from the browser. Defaults to 30 seconds.                        |
+| `requestCredentials` | `string` | `"same-origin"` | _Optional:_ Controls cookie behavior for API requests. Options: `"omit"`, `"same-origin"`, or `"include"`.                         |
 
 Example:
 
@@ -269,6 +271,7 @@ Example:
       proxy: "https://cors.pan.dev",  // Site-wide proxy (can be overridden per-spec in plugin config)
       authPersistance: "localStorage",
       requestTimeout: 60000, // 60 seconds
+      requestCredentials: "omit", // Prevent cookies from being sent with requests
     },
   },
 }

package/lib/index.js

@@ -538,7 +538,7 @@ custom_edit_url: null
                 let targetDocsPluginId;
                 if (pluginId) {
                     try {
-                        const pluginConfig = getPluginConfig(plugins, pluginId);
+                        const pluginConfig = getPluginConfig(pluginInstances, pluginId);
                         targetConfig = (_a = pluginConfig.config) !== null && _a !== void 0 ? _a : {};
                         targetDocsPluginId = pluginConfig.docsPluginId;
                     }
@@ -597,7 +597,7 @@ custom_edit_url: null
                 let targetDocsPluginId;
                 if (pluginId) {
                     try {
-                        const pluginConfig = getPluginConfig(plugins, pluginId);
+                        const pluginConfig = getPluginConfig(pluginInstances, pluginId);
                         targetConfig = (_a = pluginConfig.config) !== null && _a !== void 0 ? _a : {};
                         targetDocsPluginId = pluginConfig.docsPluginId;
                     }
@@ -677,7 +677,7 @@ custom_edit_url: null
                 let targetConfig;
                 if (pluginId) {
                     try {
-                        const pluginConfig = getPluginConfig(plugins, pluginId);
+                        const pluginConfig = getPluginConfig(pluginInstances, pluginId);
                         targetConfig = (_a = pluginConfig.config) !== null && _a !== void 0 ? _a : {};
                     }
                     catch {
@@ -728,7 +728,7 @@ custom_edit_url: null
                 let targetConfig;
                 if (pluginId) {
                     try {
-                        const pluginConfig = getPluginConfig(plugins, pluginId);
+                        const pluginConfig = getPluginConfig(pluginInstances, pluginId);
                         targetConfig = (_a = pluginConfig.config) !== null && _a !== void 0 ? _a : {};
                     }
                     catch {

package/lib/markdown/createLicense.js

@@ -11,7 +11,7 @@ const utils_1 = require("./utils");
 function createLicense(license) {
     if (!license || !Object.keys(license).length)
         return "";
-    const { name, url } = license;
+    const { name, url, identifier } = license;
     return (0, utils_1.create)("div", {
         style: {
             marginBottom: "var(--ifm-paragraph-margin-bottom)",
@@ -27,6 +27,10 @@ function createLicense(license) {
                 href: url,
                 children: name !== null && name !== void 0 ? name : url,
             })),
+            (0, utils_1.guard)(identifier, () => (0, utils_1.create)("a", {
+                href: `https://spdx.org/licenses/${identifier}.html`,
+                children: name !== null && name !== void 0 ? name : identifier,
+            })),
         ],
     });
 }

package/lib/markdown/createSchema.js

@@ -30,7 +30,7 @@ function mergeAllOf(allOf) {
         console.warn(msg);
     };
     const mergedSchemas = (0, allof_merge_1.merge)(allOf, { onMergeError });
-    return mergedSchemas;
+    return mergedSchemas !== null && mergedSchemas !== void 0 ? mergedSchemas : {};
 }
 /**
  * For handling nested anyOf/oneOf.
@@ -122,7 +122,6 @@ function createProperties(schema) {
             name: "",
             required: false,
             schemaName: "object",
-            qualifierMessage: undefined,
             schema: {},
         });
     }
@@ -151,7 +150,6 @@ function createAdditionalProperties(schema) {
             name: "property name*",
             required: false,
             schemaName: "any",
-            qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
             schema: schema,
             collapsible: false,
             discriminator: false,
@@ -179,7 +177,6 @@ function createAdditionalProperties(schema) {
             name: "property name*",
             required: false,
             schemaName: schemaName,
-            qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
             schema: additionalProperties,
             collapsible: false,
             discriminator: false,
@@ -336,10 +333,6 @@ function createDetailsNode(name, schemaName, schema, required, nullable) {
                                 style: { marginTop: ".5rem", marginBottom: ".5rem" },
                                 children: (0, createDescription_1.createDescription)(description),
                             })),
-                            (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
-                                style: { marginTop: ".5rem", marginBottom: ".5rem" },
-                                children: (0, createDescription_1.createDescription)(message),
-                            })),
                             createNodes(schema, SCHEMA_TYPE),
                         ],
                     }),
@@ -465,12 +458,6 @@ function createPropertyDiscriminator(name, schemaName, schema, discriminator, re
                     },
                     children: (0, createDescription_1.createDescription)(description),
                 })),
-                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(discriminator), (message) => (0, utils_1.create)("div", {
-                    style: {
-                        paddingLeft: "1rem",
-                    },
-                    children: (0, createDescription_1.createDescription)(message),
-                })),
                 (0, utils_1.create)("DiscriminatorTabs", {
                     className: "openapi-tabs__discriminator",
                     children: Object.keys(discriminator === null || discriminator === void 0 ? void 0 : discriminator.mapping).map((key, index) => {
@@ -554,7 +541,6 @@ function createEdges({ name, schema, required, discriminator, }) {
             name,
             required: Array.isArray(required) ? required.includes(name) : required,
             schemaName: mergedSchemaName,
-            qualifierMessage: (0, schema_1.getQualifierMessage)(mergedSchemas),
             schema: mergedSchemas,
         });
     }
@@ -564,7 +550,6 @@ function createEdges({ name, schema, required, discriminator, }) {
         name,
         required: Array.isArray(required) ? required.includes(name) : required,
         schemaName: schemaName,
-        qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
         schema: schema,
     });
 }
@@ -633,15 +618,7 @@ function createNodes(schema, schemaType) {
                 marginTop: ".5rem",
                 marginBottom: ".5rem",
             },
-            children: [
-                (0, createDescription_1.createDescription)(schema.type),
-                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
-                    style: {
-                        paddingTop: "1rem",
-                    },
-                    children: (0, createDescription_1.createDescription)(message),
-                })),
-            ],
+            children: [(0, createDescription_1.createDescription)(schema.type)],
         });
     }
     // handle circular references
@@ -651,15 +628,7 @@ function createNodes(schema, schemaType) {
                 marginTop: ".5rem",
                 marginBottom: ".5rem",
             },
-            children: [
-                (0, createDescription_1.createDescription)(schema),
-                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema), (message) => (0, utils_1.create)("div", {
-                    style: {
-                        paddingTop: "1rem",
-                    },
-                    children: (0, createDescription_1.createDescription)(message),
-                })),
-            ],
+            children: [(0, createDescription_1.createDescription)(schema)],
         });
     }
     // Unknown node/schema type should return undefined

package/lib/markdown/schema.d.ts

@@ -1,3 +1,2 @@
 import { SchemaObject } from "../openapi/types";
 export declare function getSchemaName(schema: SchemaObject, circular?: boolean): string;
-export declare function getQualifierMessage(schema?: SchemaObject): string | undefined;

package/lib/markdown/schema.js

@@ -7,7 +7,6 @@
  * ========================================================================== */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSchemaName = getSchemaName;
-exports.getQualifierMessage = getQualifierMessage;
 function prettyName(schema, circular) {
     var _a, _b, _c, _d, _e;
     // Handle enum-only schemas (valid in JSON Schema)
@@ -56,107 +55,3 @@ function getSchemaName(schema, circular) {
     }
     return (_a = prettyName(schema, circular)) !== null && _a !== void 0 ? _a : "";
 }
-function getQualifierMessage(schema) {
-    // TODO:
-    // - uniqueItems
-    // - maxProperties
-    // - minProperties
-    // - multipleOf
-    if (!schema) {
-        return undefined;
-    }
-    if (schema.items &&
-        schema.minItems === undefined &&
-        schema.maxItems === undefined) {
-        return getQualifierMessage(schema.items);
-    }
-    let message = "**Possible values:** ";
-    let qualifierGroups = [];
-    if (schema.items && schema.items.enum) {
-        if (schema.items.enum) {
-            qualifierGroups.push(`[${schema.items.enum.map((e) => `\`${e}\``).join(", ")}]`);
-        }
-    }
-    if (schema.minLength || schema.maxLength) {
-        let lengthQualifier = "";
-        let minLength;
-        let maxLength;
-        if (schema.minLength && schema.minLength > 1) {
-            minLength = `\`>= ${schema.minLength} characters\``;
-        }
-        if (schema.minLength && schema.minLength === 1) {
-            minLength = `\`non-empty\``;
-        }
-        if (schema.maxLength) {
-            maxLength = `\`<= ${schema.maxLength} characters\``;
-        }
-        if (minLength && !maxLength) {
-            lengthQualifier += minLength;
-        }
-        if (maxLength && !minLength) {
-            lengthQualifier += maxLength;
-        }
-        if (minLength && maxLength) {
-            lengthQualifier += `${minLength} and ${maxLength}`;
-        }
-        qualifierGroups.push(lengthQualifier);
-    }
-    if (schema.minimum != null ||
-        schema.maximum != null ||
-        typeof schema.exclusiveMinimum === "number" ||
-        typeof schema.exclusiveMaximum === "number") {
-        let minmaxQualifier = "";
-        let minimum;
-        let maximum;
-        if (typeof schema.exclusiveMinimum === "number") {
-            minimum = `\`> ${schema.exclusiveMinimum}\``;
-        }
-        else if (schema.minimum != null && !schema.exclusiveMinimum) {
-            minimum = `\`>= ${schema.minimum}\``;
-        }
-        else if (schema.minimum != null && schema.exclusiveMinimum === true) {
-            minimum = `\`> ${schema.minimum}\``;
-        }
-        if (typeof schema.exclusiveMaximum === "number") {
-            maximum = `\`< ${schema.exclusiveMaximum}\``;
-        }
-        else if (schema.maximum != null && !schema.exclusiveMaximum) {
-            maximum = `\`<= ${schema.maximum}\``;
-        }
-        else if (schema.maximum != null && schema.exclusiveMaximum === true) {
-            maximum = `\`< ${schema.maximum}\``;
-        }
-        if (minimum && !maximum) {
-            minmaxQualifier += minimum;
-        }
-        if (maximum && !minimum) {
-            minmaxQualifier += maximum;
-        }
-        if (minimum && maximum) {
-            minmaxQualifier += `${minimum} and ${maximum}`;
-        }
-        qualifierGroups.push(minmaxQualifier);
-    }
-    if (schema.pattern) {
-        qualifierGroups.push(`Value must match regular expression \`${schema.pattern}\``);
-    }
-    // Check if discriminator mapping
-    const discriminator = schema;
-    if (discriminator.mapping) {
-        const values = Object.keys(discriminator.mapping);
-        qualifierGroups.push(`[${values.map((e) => `\`${e}\``).join(", ")}]`);
-    }
-    if (schema.enum) {
-        qualifierGroups.push(`[${schema.enum.map((e) => `\`${e}\``).join(", ")}]`);
-    }
-    if (schema.minItems) {
-        qualifierGroups.push(`\`>= ${schema.minItems}\``);
-    }
-    if (schema.maxItems) {
-        qualifierGroups.push(`\`<= ${schema.maxItems}\``);
-    }
-    if (qualifierGroups.length === 0) {
-        return undefined;
-    }
-    return message + qualifierGroups.join(", ");
-}

package/lib/markdown/utils.js

@@ -81,7 +81,9 @@ function create(tag, props, options = {}) {
     else {
         // Inline props as usual
         for (const [key, value] of Object.entries(rest)) {
-            propString += `\n  ${key}={${JSON.stringify(value)}}`;
+            if (value !== undefined) {
+                propString += `\n  ${key}={${JSON.stringify(value)}}`;
+            }
         }
     }
     let indentedChildren = render(children).replace(/^/gm, "  ");

package/lib/openapi/createSchemaExample.test.js

@@ -45,4 +45,30 @@ describe("sampleFromSchema", () => {
             expect(result).toBe("dog");
         });
     });
+    describe("allOf with incompatible types", () => {
+        it("should return undefined when allOf contains incompatible types", () => {
+            const schema = {
+                allOf: [{ type: "string" }, { type: "integer" }],
+            };
+            const context = { type: "request" };
+            const result = (0, createSchemaExample_1.sampleFromSchema)(schema, context);
+            expect(result).toBeUndefined();
+        });
+        it("should handle incompatible allOf types in a property", () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    numero: {
+                        allOf: [{ type: "string" }, { type: "integer" }],
+                    },
+                    name: {
+                        type: "string",
+                    },
+                },
+            };
+            const context = { type: "request" };
+            const result = (0, createSchemaExample_1.sampleFromSchema)(schema, context);
+            expect(result.name).toBe("string");
+        });
+    });
 });

package/lib/openapi/openapi.js

@@ -481,22 +481,26 @@ function createItems(openapiData, options, sidebarOptions) {
 /**
  * Attach Postman Request objects to the corresponding ApiItems.
  */
+function pathTemplateToRegex(pathTemplate) {
+    const pathWithTemplateTokens = pathTemplate.replace(/\{[^}]+\}/g, "__OPENAPI_PATH_PARAM__");
+    const escapedPathTemplate = pathWithTemplateTokens.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const templatePattern = escapedPathTemplate.replace(/__OPENAPI_PATH_PARAM__/g, "[^/]+");
+    return new RegExp(`^${templatePattern}$`);
+}
 function bindCollectionToApiItems(items, postmanCollection) {
+    const apiMatchers = items
+        .filter((item) => item.type === "api")
+        .map((item) => ({
+        apiItem: item,
+        method: item.api.method.toLowerCase(),
+        pathMatcher: pathTemplateToRegex(item.api.path),
+    }));
     postmanCollection.forEachItem((item) => {
         const method = item.request.method.toLowerCase();
-        const path = item.request.url
-            .getPath({ unresolved: true }) // unresolved returns "/:variableName" instead of "/<type>"
-            .replace(/(?<![a-z0-9-_]+):([a-z0-9-_]+)/gi, "{$1}"); // replace "/:variableName" with "/{variableName}"
-        const apiItem = items.find((item) => {
-            if (item.type === "info" ||
-                item.type === "tag" ||
-                item.type === "schema") {
-                return false;
-            }
-            return item.api.path === path && item.api.method === method;
-        });
-        if ((apiItem === null || apiItem === void 0 ? void 0 : apiItem.type) === "api") {
-            apiItem.api.postman = item.request;
+        const postmanPath = item.request.url.getPath({ unresolved: true });
+        const match = apiMatchers.find(({ method: itemMethod, pathMatcher }) => itemMethod === method && pathMatcher.test(postmanPath));
+        if (match) {
+            match.apiItem.api.postman = item.request;
         }
     });
 }

package/lib/openapi/openapi.test.js

@@ -78,4 +78,156 @@ describe("openapi", () => {
             expect(schemaItems[0].id).toBe("without-tags");
         });
     });
+    describe("path template and custom verb handling", () => {
+        it("binds postman requests for OpenAPI templates and path verbs", async () => {
+            const openapiData = {
+                openapi: "3.0.0",
+                info: {
+                    title: "Path Template API",
+                    version: "1.0.0",
+                },
+                paths: {
+                    "/api/resource:customVerb": {
+                        post: {
+                            summary: "Custom verb endpoint",
+                            operationId: "customVerbOperation",
+                            responses: {
+                                "200": {
+                                    description: "OK",
+                                },
+                            },
+                        },
+                    },
+                    "/api/users/{id}": {
+                        get: {
+                            summary: "Get user by ID",
+                            operationId: "getUserById",
+                            parameters: [
+                                {
+                                    name: "id",
+                                    in: "path",
+                                    required: true,
+                                    schema: {
+                                        type: "string",
+                                    },
+                                },
+                            ],
+                            responses: {
+                                "200": {
+                                    description: "OK",
+                                },
+                            },
+                        },
+                    },
+                    "/api/users/{userId}/posts/{postId}": {
+                        get: {
+                            summary: "Get user post",
+                            operationId: "getUserPost",
+                            parameters: [
+                                {
+                                    name: "userId",
+                                    in: "path",
+                                    required: true,
+                                    schema: {
+                                        type: "string",
+                                    },
+                                },
+                                {
+                                    name: "postId",
+                                    in: "path",
+                                    required: true,
+                                    schema: {
+                                        type: "string",
+                                    },
+                                },
+                            ],
+                            responses: {
+                                "200": {
+                                    description: "OK",
+                                },
+                            },
+                        },
+                    },
+                    "/files/{name}.{ext}": {
+                        get: {
+                            summary: "Get file by name and extension",
+                            operationId: "getFileByNameAndExt",
+                            parameters: [
+                                {
+                                    name: "name",
+                                    in: "path",
+                                    required: true,
+                                    schema: {
+                                        type: "string",
+                                    },
+                                },
+                                {
+                                    name: "ext",
+                                    in: "path",
+                                    required: true,
+                                    schema: {
+                                        type: "string",
+                                    },
+                                },
+                            ],
+                            responses: {
+                                "200": {
+                                    description: "OK",
+                                },
+                            },
+                        },
+                    },
+                    "/jobs/{id}:cancel": {
+                        post: {
+                            summary: "Cancel job",
+                            operationId: "cancelJob",
+                            parameters: [
+                                {
+                                    name: "id",
+                                    in: "path",
+                                    required: true,
+                                    schema: {
+                                        type: "string",
+                                    },
+                                },
+                            ],
+                            responses: {
+                                "200": {
+                                    description: "OK",
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const options = {
+                specPath: "dummy",
+                outputDir: "build",
+            };
+            const sidebarOptions = {};
+            const [items] = await (0, openapi_1.processOpenapiFile)(openapiData, options, sidebarOptions);
+            const apiItems = items.filter((item) => item.type === "api");
+            expect(apiItems).toHaveLength(5);
+            const customVerbItem = apiItems.find((item) => item.type === "api" && item.id === "custom-verb-operation");
+            expect(customVerbItem.api.path).toBe("/api/resource:customVerb");
+            expect(customVerbItem.api.method).toBe("post");
+            expect(customVerbItem.api.postman).toBeDefined();
+            const standardItem = apiItems.find((item) => item.type === "api" && item.id === "get-user-by-id");
+            expect(standardItem.api.path).toBe("/api/users/{id}");
+            expect(standardItem.api.method).toBe("get");
+            expect(standardItem.api.postman).toBeDefined();
+            const multiParamItem = apiItems.find((item) => item.type === "api" && item.id === "get-user-post");
+            expect(multiParamItem.api.path).toBe("/api/users/{userId}/posts/{postId}");
+            expect(multiParamItem.api.method).toBe("get");
+            expect(multiParamItem.api.postman).toBeDefined();
+            const sameSegmentItem = apiItems.find((item) => item.type === "api" && item.id === "get-file-by-name-and-ext");
+            expect(sameSegmentItem.api.path).toBe("/files/{name}.{ext}");
+            expect(sameSegmentItem.api.method).toBe("get");
+            expect(sameSegmentItem.api.postman).toBeDefined();
+            const templatedVerbItem = apiItems.find((item) => item.type === "api" && item.id === "cancel-job");
+            expect(templatedVerbItem.api.path).toBe("/jobs/{id}:cancel");
+            expect(templatedVerbItem.api.method).toBe("post");
+            expect(templatedVerbItem.api.postman).toBeDefined();
+        });
+    });
 });

package/lib/openapi/types.d.ts

@@ -47,6 +47,7 @@ export interface ContactObject {
 export interface LicenseObject {
     name: string;
     url?: string;
+    identifier?: string;
 }
 export interface ServerObject {
     url: string;

package/lib/openapi/utils/loadAndResolveSpec.js

@@ -104,7 +104,7 @@ async function resolveJsonRefs(specUrlOrObject) {
     }
 }
 async function loadAndResolveSpec(specUrlOrObject) {
-    const config = new openapi_core_1.Config({});
+    const config = await (0, openapi_core_1.createConfig)({});
     const bundleOpts = {
         config,
         base: process.cwd(),
@@ -121,9 +121,10 @@ async function loadAndResolveSpec(specUrlOrObject) {
     // Force dereference ?
     // bundleOpts["dereference"] = true;
     const { bundle: { parsed }, } = await (0, openapi_core_1.bundle)(bundleOpts);
+    const parsedSpec = parsed;
     //Pre-processing before resolving JSON refs
-    if (parsed.components) {
-        for (let [component, type] of Object.entries(parsed.components)) {
+    if (parsedSpec.components) {
+        for (let [component, type] of Object.entries(parsedSpec.components)) {
             if (component === "schemas") {
                 for (let [schemaKey, schemaValue] of Object.entries(type)) {
                     const title = schemaValue["title"];
@@ -134,7 +135,7 @@ async function loadAndResolveSpec(specUrlOrObject) {
             }
         }
     }
-    const resolved = await resolveJsonRefs(parsed);
+    const resolved = await resolveJsonRefs(parsedSpec);
     // Force serialization and replace circular $ref pointers
     // @ts-ignore
     const serialized = JSON.stringify(resolved, serializer());

package/lib/openapi/utils/utils/openapi.d.ts

@@ -19,8 +19,6 @@ export declare function getSerializedValue(field: any, example: any): any;
 export declare function langFromMime(contentType: string): string;
 export declare function isNamedDefinition(pointer?: string): boolean;
 export declare function getDefinitionName(pointer?: string): string | undefined;
-export declare function humanizeNumberRange(schema: OpenAPISchema): string | undefined;
-export declare function humanizeConstraints(schema: OpenAPISchema): string[];
 export declare function sortByRequired(fields: any[], order?: string[]): any[];
 export declare function sortByField(fields: any[], param: "name" | "description" | "kind"): any[];
 export declare function mergeParams(parser: OpenAPIParser, pathParams?: Array<Referenced<OpenAPIParameter>>, operationParams?: Array<Referenced<OpenAPIParameter>>): Array<Referenced<OpenAPIParameter>>;