docusaurus-plugin-openapi-docs 1.0.0

package/lib/openapi/openapi.js

@@ -0,0 +1,233 @@
+"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.processOpenapiFile = exports.processOpenapiFiles = exports.readOpenapiFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@docusaurus/utils");
+const openapi_to_postmanv2_1 = __importDefault(require("@paloaltonetworks/openapi-to-postmanv2"));
+// @ts-ignore
+const postman_collection_1 = __importDefault(require("@paloaltonetworks/postman-collection"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const json_refs_1 = __importDefault(require("json-refs"));
+const lodash_1 = require("lodash");
+const createExample_1 = require("./createExample");
+/**
+ * Finds any reference objects in the OpenAPI definition and resolves them to a finalized value.
+ */
+async function resolveRefs(openapiData) {
+    const { resolved } = await json_refs_1.default.resolveRefs(openapiData);
+    return resolved;
+}
+/**
+ * Convenience function for converting raw JSON to a Postman Collection object.
+ */
+function jsonToCollection(data) {
+    return new Promise((resolve, reject) => {
+        let schemaPack = new openapi_to_postmanv2_1.default.SchemaPack({ type: "json", data }, { schemaFaker: false });
+        schemaPack.computedOptions.schemaFaker = false;
+        schemaPack.convert((_err, conversionResult) => {
+            if (!conversionResult.result) {
+                return reject(conversionResult.reason);
+            }
+            return resolve(new postman_collection_1.default.Collection(conversionResult.output[0].data));
+        });
+    });
+}
+/**
+ * Creates a Postman Collection object from an OpenAPI definition.
+ */
+async function createPostmanCollection(openapiData) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const data = JSON.parse(JSON.stringify(openapiData));
+    // Including `servers` breaks postman, so delete all of them.
+    delete data.servers;
+    for (let pathItemObject of Object.values(data.paths)) {
+        delete pathItemObject.servers;
+        (_a = pathItemObject.get) === null || _a === void 0 ? true : delete _a.servers;
+        (_b = pathItemObject.put) === null || _b === void 0 ? true : delete _b.servers;
+        (_c = pathItemObject.post) === null || _c === void 0 ? true : delete _c.servers;
+        (_d = pathItemObject.delete) === null || _d === void 0 ? true : delete _d.servers;
+        (_e = pathItemObject.options) === null || _e === void 0 ? true : delete _e.servers;
+        (_f = pathItemObject.head) === null || _f === void 0 ? true : delete _f.servers;
+        (_g = pathItemObject.patch) === null || _g === void 0 ? true : delete _g.servers;
+        (_h = pathItemObject.trace) === null || _h === void 0 ? true : delete _h.servers;
+    }
+    return await jsonToCollection(data);
+}
+function createItems(openapiData) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    // TODO: Find a better way to handle this
+    let items = [];
+    // Only create an info page if we have a description.
+    if (openapiData.info.description) {
+        const infoPage = {
+            type: "info",
+            id: "introduction",
+            unversionedId: "introduction",
+            title: "Introduction",
+            description: openapiData.info.description,
+            slug: "/introduction",
+            frontMatter: {},
+            info: {
+                ...openapiData.info,
+                title: (_a = openapiData.info.title) !== null && _a !== void 0 ? _a : "Introduction",
+            },
+        };
+        items.push(infoPage);
+    }
+    for (let [path, pathObject] of Object.entries(openapiData.paths)) {
+        const { $ref, description, parameters, servers, summary, ...rest } = pathObject;
+        for (let [method, operationObject] of Object.entries({ ...rest })) {
+            const title = (_c = (_b = operationObject.summary) !== null && _b !== void 0 ? _b : operationObject.operationId) !== null && _c !== void 0 ? _c : "Missing summary";
+            if (operationObject.description === undefined) {
+                operationObject.description =
+                    (_e = (_d = operationObject.summary) !== null && _d !== void 0 ? _d : operationObject.operationId) !== null && _e !== void 0 ? _e : "";
+            }
+            const baseId = (0, lodash_1.kebabCase)(title);
+            const servers = (_g = (_f = operationObject.servers) !== null && _f !== void 0 ? _f : pathObject.servers) !== null && _g !== void 0 ? _g : openapiData.servers;
+            const security = (_h = operationObject.security) !== null && _h !== void 0 ? _h : openapiData.security;
+            // Add security schemes so we know how to handle security.
+            const securitySchemes = (_j = openapiData.components) === null || _j === void 0 ? void 0 : _j.securitySchemes;
+            // Make sure schemes are lowercase. See: https://github.com/cloud-annotations/docusaurus-plugin-openapi/issues/79
+            if (securitySchemes) {
+                for (let securityScheme of Object.values(securitySchemes)) {
+                    if (securityScheme.type === "http") {
+                        securityScheme.scheme = securityScheme.scheme.toLowerCase();
+                    }
+                }
+            }
+            let jsonRequestBodyExample;
+            const body = (_l = (_k = operationObject.requestBody) === null || _k === void 0 ? void 0 : _k.content) === null || _l === void 0 ? void 0 : _l["application/json"];
+            if (body === null || body === void 0 ? void 0 : body.schema) {
+                jsonRequestBodyExample = (0, createExample_1.sampleFromSchema)(body.schema);
+            }
+            // TODO: Don't include summary temporarilly
+            const { summary, ...defaults } = operationObject;
+            const apiPage = {
+                type: "api",
+                id: baseId,
+                unversionedId: baseId,
+                title: title,
+                description: description !== null && description !== void 0 ? description : "",
+                slug: "/" + baseId,
+                frontMatter: {},
+                api: {
+                    ...defaults,
+                    tags: (_m = operationObject.tags) === null || _m === void 0 ? void 0 : _m.map((tagName) => { var _a; return getTagDisplayName(tagName, (_a = openapiData.tags) !== null && _a !== void 0 ? _a : []); }),
+                    method,
+                    path,
+                    servers,
+                    security,
+                    securitySchemes,
+                    jsonRequestBodyExample,
+                    info: openapiData.info,
+                },
+            };
+            items.push(apiPage);
+        }
+    }
+    return items;
+}
+/**
+ * Attach Postman Request objects to the corresponding ApiItems.
+ */
+function bindCollectionToApiItems(items, postmanCollection) {
+    // @ts-ignore
+    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-_]+)/gi, "{$1}"); // replace "/:variableName" with "/{variableName}"
+        const apiItem = items.find((item) => {
+            if (item.type === "info") {
+                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;
+        }
+    });
+}
+async function readOpenapiFiles(openapiPath, _options) {
+    const stat = await fs_extra_1.default.lstat(openapiPath);
+    if (stat.isDirectory()) {
+        console.warn(chalk_1.default.yellow("WARNING: Loading a directory of OpenAPI definitions is experimental and subject to unannounced breaking changes."));
+        // TODO: Add config for inlcude/ignore
+        const allFiles = await (0, utils_1.Globby)(["**/*.{json,yaml,yml}"], {
+            cwd: openapiPath,
+            ignore: utils_1.GlobExcludeDefault,
+        });
+        const sources = allFiles.filter((x) => !x.includes("_category_")); // todo: regex exclude?
+        return Promise.all(sources.map(async (source) => {
+            // TODO: make a function for this
+            const fullPath = path_1.default.join(openapiPath, source);
+            const openapiString = await fs_extra_1.default.readFile(fullPath, "utf-8");
+            const data = js_yaml_1.default.load(openapiString);
+            return {
+                source: fullPath,
+                sourceDirName: path_1.default.dirname(source),
+                data,
+            };
+        }));
+    }
+    const openapiString = await fs_extra_1.default.readFile(openapiPath, "utf-8");
+    const data = js_yaml_1.default.load(openapiString);
+    return [
+        {
+            source: openapiPath,
+            sourceDirName: ".",
+            data,
+        },
+    ];
+}
+exports.readOpenapiFiles = readOpenapiFiles;
+async function processOpenapiFiles(files) {
+    const promises = files.map(async (file) => {
+        const items = await processOpenapiFile(file.data);
+        return items.map((item) => ({
+            ...item,
+        }));
+    });
+    const metadata = await Promise.all(promises);
+    const items = metadata.flat();
+    return items;
+}
+exports.processOpenapiFiles = processOpenapiFiles;
+async function processOpenapiFile(openapiDataWithRefs) {
+    const openapiData = await resolveRefs(openapiDataWithRefs);
+    const postmanCollection = await createPostmanCollection(openapiData);
+    const items = createItems(openapiData);
+    bindCollectionToApiItems(items, postmanCollection);
+    return items;
+}
+exports.processOpenapiFile = processOpenapiFile;
+// order for picking items as a display name of tags
+const tagDisplayNameProperties = ["x-displayName", "name"];
+function getTagDisplayName(tagName, tags) {
+    var _a;
+    // find the very own tagObject
+    const tagObject = (_a = tags.find((tagObject) => tagObject.name === tagName)) !== null && _a !== void 0 ? _a : {
+        // if none found, just fake one
+        name: tagName,
+    };
+    // return the first found and filled value from the property list
+    for (const property of tagDisplayNameProperties) {
+        const displayName = tagObject[property];
+        if (typeof displayName === "string") {
+            return displayName;
+        }
+    }
+    // always default to the tagName
+    return tagName;
+}

package/lib/openapi/openapi.test.d.ts

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

package/lib/openapi/openapi.test.js

@@ -0,0 +1,33 @@
+"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 });
+const path_1 = __importDefault(require("path"));
+const _1 = require(".");
+// npx jest packages/docusaurus-plugin-openapi/src/openapi/openapi.test.ts --watch
+describe("openapi", () => {
+    describe("readOpenapiFiles", () => {
+        it("readOpenapiFiles", async () => {
+            const results = await (0, _1.readOpenapiFiles)(path_1.default.join(__dirname, "__fixtures__/examples"), {});
+            const categoryMeta = results.find((x) => x.source.endsWith("_category_.json"));
+            expect(categoryMeta).toBeFalsy();
+            // console.log(results);
+            const yaml = results.find((x) => x.source.endsWith("openapi.yaml"));
+            expect(yaml).toBeTruthy();
+            expect(yaml === null || yaml === void 0 ? void 0 : yaml.sourceDirName).toBe(".");
+            const froyo = results.find((x) => x.source.endsWith("froyo.yaml"));
+            expect(froyo).toBeTruthy();
+            expect(froyo === null || froyo === void 0 ? void 0 : froyo.sourceDirName).toBe("yogurtstore");
+            const nested = results.find((x) => x.source.endsWith("nested.yaml"));
+            expect(nested).toBeTruthy();
+            expect(nested === null || nested === void 0 ? void 0 : nested.sourceDirName).toBe("yogurtstore/nested");
+        });
+    });
+});

package/lib/openapi/types.d.ts

@@ -0,0 +1,331 @@
+import type { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema";
+interface Map<T> {
+    [key: string]: T;
+}
+export interface OpenApiObject {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+export interface OpenApiObjectWithRef {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObjectWithRef;
+    components?: ComponentsObjectWithRef;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+export interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+export interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface LicenseObject {
+    name: string;
+    url?: string;
+}
+export interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: Map<ServerVariable>;
+}
+export interface ServerVariable {
+    enum?: string[];
+    default: string;
+    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>;
+}
+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 declare type PathsObject = Map<PathItemObject>;
+export declare type PathsObjectWithRef = Map<PathItemObjectWithRef>;
+export interface PathItemObject {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    servers?: ServerObject[];
+    parameters?: ParameterObject[];
+}
+export interface PathItemObjectWithRef {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObjectWithRef;
+    put?: OperationObjectWithRef;
+    post?: OperationObjectWithRef;
+    delete?: OperationObjectWithRef;
+    options?: OperationObjectWithRef;
+    head?: OperationObjectWithRef;
+    patch?: OperationObjectWithRef;
+    trace?: OperationObjectWithRef;
+    servers?: ServerObject[];
+    parameters?: (ParameterObjectWithRef | ReferenceObject)[];
+}
+export interface OperationObject {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: ParameterObject[];
+    requestBody?: RequestBodyObject;
+    responses: ResponsesObject;
+    callbacks?: Map<CallbackObject>;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+    "x-deprecated-description"?: string;
+}
+export interface OperationObjectWithRef {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObjectWithRef | ReferenceObject)[];
+    requestBody?: RequestBodyObjectWithRef | ReferenceObject;
+    responses: ResponsesObjectWithRef;
+    callbacks?: Map<CallbackObjectWithRef | ReferenceObject>;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+    "x-deprecated-description"?: string;
+}
+export interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+export interface ParameterObject {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: string;
+    allowReserved?: boolean;
+    schema?: SchemaObject;
+    example?: any;
+    examples?: Map<ExampleObject>;
+    content?: Map<MediaTypeObject>;
+}
+export interface ParameterObjectWithRef {
+    name: string;
+    in: string;
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: string;
+    allowReserved?: boolean;
+    schema?: SchemaObjectWithRef | ReferenceObject;
+    example?: any;
+    examples?: Map<ExampleObject | ReferenceObject>;
+    content?: Map<MediaTypeObjectWithRef>;
+}
+export interface RequestBodyObject {
+    description?: string;
+    content: Map<MediaTypeObject>;
+    required?: boolean;
+}
+export interface RequestBodyObjectWithRef {
+    description?: string;
+    content: Map<MediaTypeObjectWithRef>;
+    required?: boolean;
+}
+export interface MediaTypeObject {
+    schema?: SchemaObject;
+    example?: any;
+    examples?: Map<ExampleObject>;
+    encoding?: Map<EncodingObject>;
+}
+export interface MediaTypeObjectWithRef {
+    schema?: SchemaObjectWithRef | ReferenceObject;
+    example?: any;
+    examples?: Map<ExampleObject | ReferenceObject>;
+    encoding?: Map<EncodingObjectWithRef>;
+}
+export interface EncodingObject {
+    contentType?: string;
+    headers?: Map<HeaderObject>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+export interface EncodingObjectWithRef {
+    contentType?: string;
+    headers?: Map<HeaderObjectWithRef | ReferenceObject>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+export declare type ResponsesObject = Map<ResponseObject>;
+export declare type ResponsesObjectWithRef = Map<ResponseObjectWithRef | ReferenceObject>;
+export interface ResponseObject {
+    description: string;
+    headers?: Map<HeaderObject>;
+    content?: Map<MediaTypeObject>;
+    links?: Map<LinkObject>;
+}
+export interface ResponseObjectWithRef {
+    description: string;
+    headers?: Map<HeaderObjectWithRef | ReferenceObject>;
+    content?: Map<MediaTypeObjectWithRef>;
+    links?: Map<LinkObject | ReferenceObject>;
+}
+export declare type CallbackObject = Map<PathItemObject>;
+export declare type CallbackObjectWithRef = Map<PathItemObjectWithRef>;
+export interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+export interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: Map<any>;
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+}
+export declare type HeaderObject = Omit<ParameterObject, "name" | "in">;
+export declare type HeaderObjectWithRef = Omit<ParameterObjectWithRef, "name" | "in">;
+export interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    "x-displayName"?: string;
+}
+export interface ReferenceObject {
+    $ref: string;
+}
+export declare type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+export declare type SchemaObject = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf" | "not" | "items" | "properties" | "additionalProperties"> & {
+    type?: "string" | "number" | "integer" | "boolean" | "object" | "array";
+    allOf?: SchemaObject[];
+    oneOf?: SchemaObject[];
+    anyOf?: SchemaObject[];
+    not?: SchemaObject;
+    items?: SchemaObject;
+    properties?: Map<SchemaObject>;
+    additionalProperties?: boolean | SchemaObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+};
+export declare type SchemaObjectWithRef = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf" | "not" | "items" | "properties" | "additionalProperties"> & {
+    type?: "string" | "number" | "integer" | "boolean" | "object" | "array";
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: Map<SchemaObject | ReferenceObject>;
+    additionalProperties?: boolean | SchemaObject | ReferenceObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+};
+export interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: Map<string>;
+}
+export interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+export declare type SecuritySchemeObject = ApiKeySecuritySchemeObject | HttpSecuritySchemeObject | Oauth2SecuritySchemeObject | OpenIdConnectSecuritySchemeObject;
+export interface ApiKeySecuritySchemeObject {
+    type: "apiKey";
+    description?: string;
+    name: string;
+    in: "query" | "header" | "cookie";
+}
+export interface HttpSecuritySchemeObject {
+    type: "http";
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+}
+export interface Oauth2SecuritySchemeObject {
+    type: "oauth2";
+    description?: string;
+    flows: OAuthFlowsObject;
+}
+export interface OpenIdConnectSecuritySchemeObject {
+    type: "openIdConnect";
+    description?: string;
+    openIdConnectUrl: string;
+}
+export interface OAuthFlowsObject {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+export interface OAuthFlowObject {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Map<string>;
+}
+export declare type SecurityRequirementObject = Map<string[]>;
+export {};

package/lib/openapi/types.js

@@ -0,0 +1,8 @@
+"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.
+ * ========================================================================== */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/options.d.ts

@@ -0,0 +1,4 @@
+import { Joi } from "@docusaurus/utils-validation";
+import type { PluginOptions } from "./types";
+export declare const DEFAULT_OPTIONS: PluginOptions;
+export declare const OptionsSchema: Joi.ObjectSchema<any>;

package/lib/options.js

@@ -0,0 +1,18 @@
+"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.
+ * ========================================================================== */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionsSchema = exports.DEFAULT_OPTIONS = void 0;
+const utils_validation_1 = require("@docusaurus/utils-validation");
+exports.DEFAULT_OPTIONS = {
+    id: "default",
+    config: {},
+};
+exports.OptionsSchema = utils_validation_1.Joi.object({
+    id: utils_validation_1.Joi.string().default(exports.DEFAULT_OPTIONS.id),
+    config: utils_validation_1.Joi.object().default(exports.DEFAULT_OPTIONS.config),
+});

package/lib/sidebars/index.d.ts

@@ -0,0 +1,3 @@
+import { ProcessedSidebar } from "@docusaurus/plugin-content-docs/src/sidebars/types";
+import type { SidebarOptions, APIOptions, ApiMetadata } from "../types";
+export default function generateSidebarSlice(sidebarOptions: SidebarOptions, options: APIOptions, api: ApiMetadata[]): ProcessedSidebar;