docusaurus-plugin-openapi-docs 4.3.7 → 4.5.0

package/lib/openapi/createSchemaExample.js

@@ -0,0 +1,231 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleFromSchema = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const merge_1 = __importDefault(require("lodash/merge"));
+const createSchema_1 = require("../markdown/createSchema");
+const primitives = {
+    string: {
+        default: () => "string",
+        email: () => "user@example.com",
+        date: () => "2024-07-29",
+        "date-time": () => "2024-07-29T15:51:28.071Z",
+        uuid: () => "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+        hostname: () => "example.com",
+        ipv4: () => "198.51.100.42",
+        ipv6: () => "2001:0db8:5b96:0000:0000:426f:8e17:642a",
+    },
+    number: {
+        default: () => 0,
+        float: () => 0.0,
+    },
+    integer: {
+        default: () => 0,
+    },
+    boolean: {
+        default: (schema) => typeof schema.default === "boolean" ? schema.default : true,
+    },
+    object: {},
+    array: {},
+    null: {
+        default: () => "null",
+    },
+};
+function shouldExcludeProperty(prop, context) {
+    if (prop.deprecated) {
+        return true;
+    }
+    if (context.type === "request") {
+        return prop.readOnly === true;
+    }
+    else {
+        return prop.writeOnly === true;
+    }
+}
+function sampleFromProp(name, prop, obj, context) {
+    // Handle resolved circular props
+    if (typeof prop === "object" && Object.keys(prop).length === 0) {
+        obj[name] = prop;
+        return obj;
+    }
+    // TODO: handle discriminators
+    if (prop.oneOf) {
+        obj[name] = (0, exports.sampleFromSchema)(prop.oneOf[0], context);
+    }
+    else if (prop.anyOf) {
+        obj[name] = (0, exports.sampleFromSchema)(prop.anyOf[0], context);
+    }
+    else if (prop.allOf) {
+        const mergedSchemas = (0, createSchema_1.mergeAllOf)(prop);
+        sampleFromProp(name, mergedSchemas, obj, context);
+    }
+    else {
+        obj[name] = (0, exports.sampleFromSchema)(prop, context);
+    }
+    return obj;
+}
+const sampleFromSchema = (schema = {}, context) => {
+    try {
+        // deep copy schema before processing
+        let schemaCopy = JSON.parse(JSON.stringify(schema));
+        let { type, example, allOf, properties, items, oneOf, anyOf } = schemaCopy;
+        if (example !== undefined) {
+            return example;
+        }
+        if (oneOf) {
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, oneOf[0]);
+                delete combinedSchemas.oneOf;
+                return (0, exports.sampleFromSchema)(combinedSchemas, context);
+            }
+            // Just go with first schema
+            return (0, exports.sampleFromSchema)(oneOf[0], context);
+        }
+        if (anyOf) {
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, anyOf[0]);
+                delete combinedSchemas.anyOf;
+                return (0, exports.sampleFromSchema)(combinedSchemas, context);
+            }
+            // Just go with first schema
+            return (0, exports.sampleFromSchema)(anyOf[0], context);
+        }
+        if (allOf) {
+            const mergedSchemas = (0, createSchema_1.mergeAllOf)(schemaCopy);
+            if (mergedSchemas.properties) {
+                for (const [key, value] of Object.entries(mergedSchemas.properties)) {
+                    if (shouldExcludeProperty(value, context)) {
+                        delete mergedSchemas.properties[key];
+                    }
+                }
+            }
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, mergedSchemas);
+                delete combinedSchemas.allOf;
+                return (0, exports.sampleFromSchema)(combinedSchemas, context);
+            }
+            return (0, exports.sampleFromSchema)(mergedSchemas, context);
+        }
+        if (!type) {
+            if (properties) {
+                type = "object";
+            }
+            else if (items) {
+                type = "array";
+            }
+            else {
+                return;
+            }
+        }
+        if (type === "object") {
+            let obj = {};
+            for (let [name, prop] of Object.entries(properties !== null && properties !== void 0 ? properties : {})) {
+                if (prop.properties) {
+                    for (const [key, value] of Object.entries(prop.properties)) {
+                        if (shouldExcludeProperty(value, context)) {
+                            delete prop.properties[key];
+                        }
+                    }
+                }
+                if (prop.items && prop.items.properties) {
+                    for (const [key, value] of Object.entries(prop.items.properties)) {
+                        if (shouldExcludeProperty(value, context)) {
+                            delete prop.items.properties[key];
+                        }
+                    }
+                }
+                if (shouldExcludeProperty(prop, context)) {
+                    continue;
+                }
+                // Resolve schema from prop recursively
+                obj = sampleFromProp(name, prop, obj, context);
+            }
+            return obj;
+        }
+        if (type === "array") {
+            if (Array.isArray(items === null || items === void 0 ? void 0 : items.anyOf)) {
+                return processArrayItems(items, "anyOf", context);
+            }
+            if (Array.isArray(items === null || items === void 0 ? void 0 : items.oneOf)) {
+                return processArrayItems(items, "oneOf", context);
+            }
+            return normalizeArray((0, exports.sampleFromSchema)(items, context));
+        }
+        if (schemaCopy.enum) {
+            if (schemaCopy.default) {
+                return schemaCopy.default;
+            }
+            return normalizeArray(schemaCopy.enum)[0];
+        }
+        if (shouldExcludeProperty(schemaCopy, context)) {
+            return undefined;
+        }
+        return primitive(schemaCopy);
+    }
+    catch (err) {
+        console.error(chalk_1.default.yellow("WARNING: failed to create example from schema object:", err));
+        return;
+    }
+};
+exports.sampleFromSchema = sampleFromSchema;
+function primitive(schema = {}) {
+    let { type, format } = schema;
+    if (type === undefined) {
+        return;
+    }
+    // If type is an array, use the first type
+    if (Array.isArray(type)) {
+        type = type[0];
+        if (type === undefined) {
+            return;
+        }
+    }
+    // Use schema default if available, otherwise use type default
+    if (schema.default !== undefined) {
+        return schema.default;
+    }
+    const typeConfig = primitives[type];
+    if (typeConfig) {
+        if (format !== undefined && typeConfig[format] !== undefined) {
+            return typeConfig[format](schema);
+        }
+        if (typeConfig.default !== undefined) {
+            return typeConfig.default(schema);
+        }
+    }
+    return "Unknown Type: " + schema.type;
+}
+function normalizeArray(arr) {
+    if (Array.isArray(arr)) {
+        return arr;
+    }
+    return [arr];
+}
+function processArrayItems(items, schemaType, context) {
+    const itemsArray = items[schemaType];
+    return itemsArray.map((item) => {
+        // If items has properties, merge them with each item
+        if (items.properties) {
+            const combinedSchema = {
+                ...item,
+                properties: {
+                    ...items.properties, // Common properties from parent
+                    ...item.properties, // Specific properties from this anyOf/oneOf item
+                },
+            };
+            // Remove anyOf/oneOf to prevent infinite recursion when calling sampleFromSchema
+            delete combinedSchema[schemaType];
+            return (0, exports.sampleFromSchema)(combinedSchema, context);
+        }
+        return (0, exports.sampleFromSchema)(item, context);
+    });
+}

package/lib/openapi/openapi.js

@@ -5,6 +5,39 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  * ========================================================================== */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -22,7 +55,7 @@ const kebabCase_1 = __importDefault(require("lodash/kebabCase"));
 const unionBy_1 = __importDefault(require("lodash/unionBy"));
 const uniq_1 = __importDefault(require("lodash/uniq"));
 const openapi_to_postmanv2_1 = __importDefault(require("openapi-to-postmanv2"));
-const postman_collection_1 = __importDefault(require("postman-collection"));
+const sdk = __importStar(require("postman-collection"));
 const createRequestExample_1 = require("./createRequestExample");
 const index_1 = require("../index");
 const createResponseExample_1 = require("./createResponseExample");
@@ -38,7 +71,7 @@ function jsonToCollection(data) {
             if (!conversionResult.result) {
                 return reject(conversionResult.reason);
             }
-            return resolve(new postman_collection_1.default.Collection(conversionResult.output[0].data));
+            return resolve(new sdk.Collection(conversionResult.output[0].data));
         });
     });
 }
@@ -211,6 +244,7 @@ function createItems(openapiData, options, sidebarOptions) {
                     jsonRequestBodyExample,
                     info: openapiData.info,
                 },
+                position: operationObject["x-position"],
             };
             items.push(apiPage);
         }
@@ -406,6 +440,21 @@ function createItems(openapiData, options, sidebarOptions) {
             items.push(tagPage);
         });
     }
+    items.sort((a, b) => {
+        // Items with position come first, sorted by position
+        if (a.position !== undefined && b.position !== undefined) {
+            return a.position - b.position;
+        }
+        // Items with position come before items without position
+        if (a.position !== undefined) {
+            return -1;
+        }
+        if (b.position !== undefined) {
+            return 1;
+        }
+        // If neither has position, maintain original order
+        return 0;
+    });
     return items;
 }
 /**

package/lib/openapi/types.d.ts

@@ -1,7 +1,4 @@
-import type { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema";
-interface Map<T> {
-    [key: string]: T;
-}
+import type { JSONSchema4, JSONSchema6, JSONSchema7, JSONSchema7TypeName } from "json-schema";
 export interface OpenApiObject {
     openapi: string;
     info: InfoObject;
@@ -54,7 +51,7 @@ export interface LicenseObject {
 export interface ServerObject {
     url: string;
     description?: string;
-    variables?: Map<ServerVariable>;
+    variables?: Record<string, ServerVariable>;
 }
 export interface ServerVariable {
     enum?: string[];
@@ -62,29 +59,29 @@ export interface ServerVariable {
     description?: string;
 }
 export interface ComponentsObject {
-    schemas?: Map<SchemaObject>;
-    responses?: Map<ResponseObject>;
-    parameters?: Map<ParameterObject>;
-    examples?: Map<ExampleObject>;
-    requestBodies?: Map<RequestBodyObject>;
-    headers?: Map<HeaderObject>;
-    securitySchemes?: Map<SecuritySchemeObject>;
-    links?: Map<LinkObject>;
-    callbacks?: Map<CallbackObject>;
+    schemas?: Record<string, SchemaObject>;
+    responses?: Record<string, ResponseObject>;
+    parameters?: Record<string, ParameterObject>;
+    examples?: Record<string, ExampleObject>;
+    requestBodies?: Record<string, RequestBodyObject>;
+    headers?: Record<string, HeaderObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject>;
+    links?: Record<string, LinkObject>;
+    callbacks?: Record<string, CallbackObject>;
 }
 export interface ComponentsObjectWithRef {
-    schemas?: Map<SchemaObjectWithRef | ReferenceObject>;
-    responses?: Map<ResponseObjectWithRef | ReferenceObject>;
-    parameters?: Map<ParameterObjectWithRef | ReferenceObject>;
-    examples?: Map<ExampleObject | ReferenceObject>;
-    requestBodies?: Map<RequestBodyObjectWithRef | ReferenceObject>;
-    headers?: Map<HeaderObjectWithRef | ReferenceObject>;
-    securitySchemes?: Map<SecuritySchemeObject | ReferenceObject>;
-    links?: Map<LinkObject | ReferenceObject>;
-    callbacks?: Map<CallbackObjectWithRef | ReferenceObject>;
-}
-export type PathsObject = Map<PathItemObject>;
-export type PathsObjectWithRef = Map<PathItemObjectWithRef>;
+    schemas?: Record<string, SchemaObjectWithRef | ReferenceObject>;
+    responses?: Record<string, ResponseObjectWithRef | ReferenceObject>;
+    parameters?: Record<string, ParameterObjectWithRef | ReferenceObject>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObjectWithRef | ReferenceObject>;
+    headers?: Record<string, HeaderObjectWithRef | ReferenceObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+    callbacks?: Record<string, CallbackObjectWithRef | ReferenceObject>;
+}
+export type PathsObject = Record<string, PathItemObject>;
+export type PathsObjectWithRef = Record<string, PathItemObjectWithRef>;
 export interface PathItemObject {
     $ref?: string;
     summary?: string;
@@ -124,10 +121,11 @@ export interface OperationObject {
     parameters?: ParameterObject[];
     requestBody?: RequestBodyObject;
     responses: ResponsesObject;
-    callbacks?: Map<CallbackObject>;
+    callbacks?: Record<string, CallbackObject>;
     deprecated?: boolean;
     security?: SecurityRequirementObject[];
     servers?: ServerObject[];
+    "x-position"?: number;
     "x-deprecated-description"?: string;
 }
 export interface OperationObjectWithRef {
@@ -139,7 +137,7 @@ export interface OperationObjectWithRef {
     parameters?: (ParameterObjectWithRef | ReferenceObject)[];
     requestBody?: RequestBodyObjectWithRef | ReferenceObject;
     responses: ResponsesObjectWithRef;
-    callbacks?: Map<CallbackObjectWithRef | ReferenceObject>;
+    callbacks?: Record<string, CallbackObjectWithRef | ReferenceObject>;
     deprecated?: boolean;
     security?: SecurityRequirementObject[];
     servers?: ServerObject[];
@@ -161,8 +159,8 @@ export interface ParameterObject {
     allowReserved?: boolean;
     schema?: SchemaObject;
     example?: any;
-    examples?: Map<ExampleObject>;
-    content?: Map<MediaTypeObject>;
+    examples?: Record<string, ExampleObject>;
+    content?: Record<string, MediaTypeObject>;
     param?: Object;
     "x-enumDescriptions"?: Record<string, string>;
 }
@@ -178,62 +176,62 @@ export interface ParameterObjectWithRef {
     allowReserved?: boolean;
     schema?: SchemaObjectWithRef | ReferenceObject;
     example?: any;
-    examples?: Map<ExampleObject | ReferenceObject>;
-    content?: Map<MediaTypeObjectWithRef>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    content?: Record<string, MediaTypeObjectWithRef>;
 }
 export interface RequestBodyObject {
     description?: string;
-    content: Map<MediaTypeObject>;
+    content: Record<string, MediaTypeObject>;
     required?: boolean;
 }
 export interface RequestBodyObjectWithRef {
     description?: string;
-    content: Map<MediaTypeObjectWithRef>;
+    content: Record<string, MediaTypeObjectWithRef>;
     required?: boolean;
 }
 export interface MediaTypeObject {
     schema?: SchemaObject;
     example?: any;
-    examples?: Map<ExampleObject>;
-    encoding?: Map<EncodingObject>;
+    examples?: Record<string, ExampleObject>;
+    encoding?: Record<string, EncodingObject>;
     type?: any;
 }
 export interface MediaTypeObjectWithRef {
     schema?: SchemaObjectWithRef | ReferenceObject;
     example?: any;
-    examples?: Map<ExampleObject | ReferenceObject>;
-    encoding?: Map<EncodingObjectWithRef>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    encoding?: Record<string, EncodingObjectWithRef>;
 }
 export interface EncodingObject {
     contentType?: string;
-    headers?: Map<HeaderObject>;
+    headers?: Record<string, HeaderObject>;
     style?: string;
     explode?: boolean;
     allowReserved?: boolean;
 }
 export interface EncodingObjectWithRef {
     contentType?: string;
-    headers?: Map<HeaderObjectWithRef | ReferenceObject>;
+    headers?: Record<string, HeaderObjectWithRef | ReferenceObject>;
     style?: string;
     explode?: boolean;
     allowReserved?: boolean;
 }
-export type ResponsesObject = Map<ResponseObject>;
-export type ResponsesObjectWithRef = Map<ResponseObjectWithRef | ReferenceObject>;
+export type ResponsesObject = Record<string, ResponseObject>;
+export type ResponsesObjectWithRef = Record<string, ResponseObjectWithRef | ReferenceObject>;
 export interface ResponseObject {
     description: string;
-    headers?: Map<HeaderObject>;
-    content?: Map<MediaTypeObject>;
-    links?: Map<LinkObject>;
+    headers?: Record<string, HeaderObject>;
+    content?: Record<string, MediaTypeObject>;
+    links?: Record<string, LinkObject>;
 }
 export interface ResponseObjectWithRef {
     description: string;
-    headers?: Map<HeaderObjectWithRef | ReferenceObject>;
-    content?: Map<MediaTypeObjectWithRef>;
-    links?: Map<LinkObject | ReferenceObject>;
+    headers?: Record<string, HeaderObjectWithRef | ReferenceObject>;
+    content?: Record<string, MediaTypeObjectWithRef>;
+    links?: Record<string, LinkObject | ReferenceObject>;
 }
-export type CallbackObject = Map<PathItemObject>;
-export type CallbackObjectWithRef = Map<PathItemObjectWithRef>;
+export type CallbackObject = Record<string, PathItemObject>;
+export type CallbackObjectWithRef = Record<string, PathItemObjectWithRef>;
 export interface ExampleObject {
     summary?: string;
     description?: string;
@@ -243,7 +241,7 @@ export interface ExampleObject {
 export interface LinkObject {
     operationRef?: string;
     operationId?: string;
-    parameters?: Map<any>;
+    parameters?: Record<string, any>;
     requestBody?: any;
     description?: string;
     server?: ServerObject;
@@ -264,14 +262,15 @@ export interface ReferenceObject {
     $ref: string;
 }
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+export type SchemaType = JSONSchema7TypeName;
 export type SchemaObject = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf" | "not" | "items" | "properties" | "additionalProperties"> & {
-    type?: "string" | "number" | "integer" | "boolean" | "object" | "array";
+    type?: SchemaType;
     allOf?: SchemaObject[];
     oneOf?: SchemaObject[];
     anyOf?: SchemaObject[];
     not?: SchemaObject;
     items?: SchemaObject;
-    properties?: Map<SchemaObject>;
+    properties?: Record<string, SchemaObject>;
     additionalProperties?: boolean | SchemaObject;
     nullable?: boolean;
     discriminator?: DiscriminatorObject;
@@ -285,13 +284,13 @@ export type SchemaObject = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf"
     "x-enumDescriptions"?: Record<string, string>;
 };
 export type SchemaObjectWithRef = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf" | "not" | "items" | "properties" | "additionalProperties"> & {
-    type?: "string" | "number" | "integer" | "boolean" | "object" | "array";
+    type?: SchemaType;
     allOf?: (SchemaObject | ReferenceObject)[];
     oneOf?: (SchemaObject | ReferenceObject)[];
     anyOf?: (SchemaObject | ReferenceObject)[];
     not?: SchemaObject | ReferenceObject;
     items?: SchemaObject | ReferenceObject;
-    properties?: Map<SchemaObject | ReferenceObject>;
+    properties?: Record<string, SchemaObject | ReferenceObject>;
     additionalProperties?: boolean | SchemaObject | ReferenceObject;
     nullable?: boolean;
     discriminator?: DiscriminatorObject;
@@ -304,7 +303,7 @@ export type SchemaObjectWithRef = Omit<JSONSchema, "type" | "allOf" | "oneOf" |
 };
 export interface DiscriminatorObject {
     propertyName: string;
-    mapping?: Map<string>;
+    mapping?: Record<string, string>;
 }
 export interface XMLObject {
     name?: string;
@@ -348,7 +347,6 @@ export interface OAuthFlowObject {
     authorizationUrl?: string;
     tokenUrl?: string;
     refreshUrl?: string;
-    scopes: Map<string>;
+    scopes: Record<string, string>;
 }
-export type SecurityRequirementObject = Map<string[]>;
-export {};
+export type SecurityRequirementObject = Record<string, string[]>;

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

@@ -16,7 +16,7 @@ export declare class OpenAPIParser {
     /**
      * get spec part by JsonPointer ($ref)
      */
-    byRef: <T extends unknown = any>(ref: string) => T | undefined;
+    byRef: <T extends any = any>(ref: string) => T | undefined;
     /**
      * checks if the object is OpenAPI reference (contains $ref property)
      */

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

@@ -76,6 +76,7 @@ export interface OpenAPIOperation {
     servers?: OpenAPIServer[];
     "x-codeSamples"?: OpenAPIXCodeSample[];
     "x-code-samples"?: OpenAPIXCodeSample[];
+    "x-position"?: number;
 }
 export interface OpenAPIParameter {
     name: string;

package/lib/options.js

@@ -35,6 +35,9 @@ exports.OptionsSchema = utils_validation_1.Joi.object({
         proxy: utils_validation_1.Joi.string(),
         outputDir: utils_validation_1.Joi.string().required(),
         template: utils_validation_1.Joi.string(),
+        infoTemplate: utils_validation_1.Joi.string(),
+        tagTemplate: utils_validation_1.Joi.string(),
+        schemaTemplate: utils_validation_1.Joi.string(),
         downloadUrl: utils_validation_1.Joi.string(),
         hideSendButton: utils_validation_1.Joi.boolean(),
         showExtensions: utils_validation_1.Joi.boolean(),

package/lib/types.d.ts

@@ -1,5 +1,4 @@
 import { SidebarItemDoc } from "@docusaurus/plugin-content-docs/src/sidebars/types";
-import type Request from "postman-collection";
 import { InfoObject, OperationObject, SchemaObject, SecuritySchemeObject, TagObject } from "./openapi/types";
 export type { PropSidebarItemCategory, SidebarItemLink, PropSidebar, PropSidebarItem, } from "@docusaurus/plugin-content-docs-types";
 export interface PluginOptions {
@@ -14,6 +13,9 @@ export interface APIOptions {
     specPath: string;
     outputDir: string;
     template?: string;
+    infoTemplate?: string;
+    tagTemplate?: string;
+    schemaTemplate?: string;
     downloadUrl?: string;
     hideSendButton?: boolean;
     showExtensions?: boolean;
@@ -82,6 +84,7 @@ export interface ApiMetadataBase {
     frontMatter: Record<string, unknown>;
     method?: string;
     path?: string;
+    position?: number;
 }
 export interface ApiPageMetadata extends ApiMetadataBase {
     json?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-plugin-openapi-docs",
   "description": "OpenAPI plugin for Docusaurus.",
-  "version": "4.3.7",
+  "version": "4.5.0",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -65,5 +65,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "e4d3ec4ebfb8415e97951076ce2f0901e8d88168"
+  "gitHead": "cb0ed6e02d7a963d51073e2bfd78d944fbb7ee34"
 }