docusaurus-plugin-openapi-docs 0.0.0-1000

package/lib/markdown/createStatusCodes.d.ts

@@ -0,0 +1,9 @@
+import { ApiItem } from "../types";
+export default function json2xml(o: any, tab: any): string;
+interface Props {
+    id?: string;
+    label?: string;
+    responses: ApiItem["responses"];
+}
+export declare function createStatusCodes({ id, label, responses }: Props): string[];
+export {};

package/lib/markdown/createStatusCodes.js

@@ -0,0 +1,63 @@
+"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.default = json2xml;
+exports.createStatusCodes = createStatusCodes;
+const utils_1 = require("./utils");
+function json2xml(o, tab) {
+    var toXml = function (v, name, ind) {
+        var xml = "";
+        if (v instanceof Array) {
+            for (var i = 0, n = v.length; i < n; i++)
+                xml += ind + toXml(v[i], name, ind + "\t") + "\n";
+        }
+        else if (typeof v == "object") {
+            var hasChild = false;
+            xml += ind + "<" + name;
+            for (var m in v) {
+                if (m.charAt(0) === "@")
+                    xml += " " + m.substr(1) + '="' + v[m].toString() + '"';
+                else
+                    hasChild = true;
+            }
+            xml += hasChild ? ">" : "/>";
+            if (hasChild) {
+                for (var m2 in v) {
+                    if (m2 === "#text")
+                        xml += v[m2];
+                    else if (m2 === "#cdata")
+                        xml += "<![CDATA[" + v[m2] + "]]>";
+                    else if (m2.charAt(0) !== "@")
+                        xml += toXml(v[m2], m2, ind + "\t");
+                }
+                xml +=
+                    (xml.charAt(xml.length - 1) === "\n" ? ind : "") +
+                        "</" +
+                        name +
+                        ">";
+            }
+        }
+        else {
+            xml += ind + "<" + name + ">" + v.toString() + "</" + name + ">";
+        }
+        return xml;
+    }, xml = "";
+    for (var m3 in o)
+        xml += toXml(o[m3], m3, "");
+    return tab ? xml.replace(/\t/g, tab) : xml.replace(/\t|\n/g, "");
+}
+function createStatusCodes({ id, label, responses }) {
+    return [
+        (0, utils_1.create)("StatusCodes", {
+            id: id,
+            label: label,
+            responses: responses,
+        }),
+        "\n\n",
+    ];
+}

package/lib/markdown/createTermsOfService.d.ts

@@ -0,0 +1 @@
+export declare function createTermsOfService(termsOfService: string | undefined): string;

package/lib/markdown/createTermsOfService.js

@@ -0,0 +1,31 @@
+"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.createTermsOfService = createTermsOfService;
+const utils_1 = require("./utils");
+function createTermsOfService(termsOfService) {
+    if (!termsOfService)
+        return "";
+    return (0, utils_1.create)("div", {
+        style: {
+            marginBottom: "var(--ifm-paragraph-margin-bottom)",
+        },
+        children: [
+            (0, utils_1.create)("h3", {
+                style: {
+                    marginBottom: "0.25rem",
+                },
+                children: "Terms of Service",
+            }),
+            (0, utils_1.create)("a", {
+                href: `${termsOfService}`,
+                children: `{'${termsOfService}'}`,
+            }),
+        ],
+    });
+}

package/lib/markdown/createVendorExtensions.d.ts

@@ -0,0 +1 @@
+export declare function createVendorExtensions(extensions: any): string | undefined;

package/lib/markdown/createVendorExtensions.js

@@ -0,0 +1,24 @@
+"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.createVendorExtensions = createVendorExtensions;
+function createVendorExtensions(extensions) {
+    if (!extensions || typeof extensions !== "object") {
+        return undefined;
+    }
+    const rows = [];
+    extensions.map((extension) => {
+        const extensionRow = () => {
+            return `${extension.key}: ${JSON.stringify(extension.value)}`;
+        };
+        return rows.push(extensionRow());
+    });
+    return `\n\n\`\`\`
+${rows.join("\n")}
+\`\`\`\n\n`;
+}

package/lib/markdown/createVersionBadge.d.ts

@@ -0,0 +1 @@
+export declare function createVersionBadge(version: string | undefined): string;

package/lib/markdown/createVersionBadge.js

@@ -0,0 +1,19 @@
+"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.createVersionBadge = createVersionBadge;
+const utils_1 = require("./utils");
+function createVersionBadge(version) {
+    return (0, utils_1.guard)(version, (version) => [
+        (0, utils_1.create)("span", {
+            className: "theme-doc-version-badge badge badge--secondary",
+            children: `Version: ${escape(version)}`,
+        }, { inline: true }),
+        `\n\n`,
+    ]);
+}

package/lib/markdown/index.d.ts

@@ -0,0 +1,5 @@
+import { ApiPageMetadata, InfoPageMetadata, SchemaPageMetadata, TagPageMetadata } from "../types";
+export declare function createApiPageMD({ title, api: { deprecated, "x-deprecated-description": deprecatedDescription, description, method, path, extensions, parameters, requestBody, responses, callbacks, }, infoPath, frontMatter, }: ApiPageMetadata): string;
+export declare function createInfoPageMD({ info: { title, version, description, contact, license, termsOfService, logo, darkLogo, }, securitySchemes, downloadUrl, }: InfoPageMetadata): string;
+export declare function createTagPageMD({ tag: { description } }: TagPageMetadata): string;
+export declare function createSchemaPageMD({ schema }: SchemaPageMetadata): string;

package/lib/markdown/index.js

@@ -0,0 +1,92 @@
+"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.createApiPageMD = createApiPageMD;
+exports.createInfoPageMD = createInfoPageMD;
+exports.createTagPageMD = createTagPageMD;
+exports.createSchemaPageMD = createSchemaPageMD;
+const createAuthentication_1 = require("./createAuthentication");
+const createAuthorization_1 = require("./createAuthorization");
+const createCallbacks_1 = require("./createCallbacks");
+const createContactInfo_1 = require("./createContactInfo");
+const createDeprecationNotice_1 = require("./createDeprecationNotice");
+const createDescription_1 = require("./createDescription");
+const createDownload_1 = require("./createDownload");
+const createHeading_1 = require("./createHeading");
+const createLicense_1 = require("./createLicense");
+const createLogo_1 = require("./createLogo");
+const createMethodEndpoint_1 = require("./createMethodEndpoint");
+const createParamsDetails_1 = require("./createParamsDetails");
+const createRequestBodyDetails_1 = require("./createRequestBodyDetails");
+const createRequestHeader_1 = require("./createRequestHeader");
+const createStatusCodes_1 = require("./createStatusCodes");
+const createTermsOfService_1 = require("./createTermsOfService");
+const createVendorExtensions_1 = require("./createVendorExtensions");
+const createVersionBadge_1 = require("./createVersionBadge");
+const utils_1 = require("./utils");
+function createApiPageMD({ title, api: { deprecated, "x-deprecated-description": deprecatedDescription, description, method, path, extensions, parameters, requestBody, responses, callbacks, }, infoPath, frontMatter, }) {
+    return (0, utils_1.render)([
+        `import MethodEndpoint from "@theme/ApiExplorer/MethodEndpoint";\n`,
+        `import ParamsDetails from "@theme/ParamsDetails";\n`,
+        `import RequestSchema from "@theme/RequestSchema";\n`,
+        `import StatusCodes from "@theme/StatusCodes";\n`,
+        `import OperationTabs from "@theme/OperationTabs";\n`,
+        `import TabItem from "@theme/TabItem";\n`,
+        `import Heading from "@theme/Heading";\n\n`,
+        (0, createHeading_1.createHeading)(title),
+        (0, createMethodEndpoint_1.createMethodEndpoint)(method, path),
+        infoPath && (0, createAuthorization_1.createAuthorization)(infoPath),
+        frontMatter.show_extensions
+            ? (0, createVendorExtensions_1.createVendorExtensions)(extensions)
+            : undefined,
+        (0, createDeprecationNotice_1.createDeprecationNotice)({ deprecated, description: deprecatedDescription }),
+        (0, createDescription_1.createDescription)(description),
+        requestBody || parameters ? (0, createRequestHeader_1.createRequestHeader)("Request") : undefined,
+        (0, createParamsDetails_1.createParamsDetails)({ parameters }),
+        (0, createRequestBodyDetails_1.createRequestBodyDetails)({
+            title: "Body",
+            body: requestBody,
+        }),
+        (0, createStatusCodes_1.createStatusCodes)({ responses }),
+        (0, createCallbacks_1.createCallbacks)({ callbacks }),
+    ]);
+}
+function createInfoPageMD({ info: { title, version, description, contact, license, termsOfService, logo, darkLogo, }, securitySchemes, downloadUrl, }) {
+    return (0, utils_1.render)([
+        `import ApiLogo from "@theme/ApiLogo";\n`,
+        `import Heading from "@theme/Heading";\n`,
+        `import SchemaTabs from "@theme/SchemaTabs";\n`,
+        `import TabItem from "@theme/TabItem";\n`,
+        `import Export from "@theme/ApiExplorer/Export";\n\n`,
+        (0, createVersionBadge_1.createVersionBadge)(version),
+        (0, createDownload_1.createDownload)(downloadUrl),
+        (0, createHeading_1.createHeading)(title),
+        (0, createLogo_1.createLogo)(logo, darkLogo),
+        (0, createDescription_1.createDescription)(description),
+        (0, createAuthentication_1.createAuthentication)(securitySchemes),
+        (0, createContactInfo_1.createContactInfo)(contact),
+        (0, createTermsOfService_1.createTermsOfService)(termsOfService),
+        (0, createLicense_1.createLicense)(license),
+    ]);
+}
+function createTagPageMD({ tag: { description } }) {
+    return (0, utils_1.render)([(0, createDescription_1.createDescription)(description)]);
+}
+function createSchemaPageMD({ schema }) {
+    const { title = "", description } = schema;
+    return (0, utils_1.render)([
+        `import Schema from "@theme/Schema";\n`,
+        `import Heading from "@theme/Heading";\n\n`,
+        (0, createHeading_1.createHeading)(title.replace(utils_1.lessThan, "<").replace(utils_1.greaterThan, ">")),
+        (0, createDescription_1.createDescription)(description),
+        (0, utils_1.create)("Schema", {
+            schema: schema,
+            schemaType: "response",
+        }),
+    ]);
+}

package/lib/markdown/schema.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,154 @@
+"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.getSchemaName = getSchemaName;
+exports.getQualifierMessage = getQualifierMessage;
+function prettyName(schema, circular) {
+    var _a, _b, _c, _d, _e;
+    if (schema.format) {
+        return schema.format;
+    }
+    if (schema.allOf) {
+        if (typeof schema.allOf[0] === "string") {
+            // @ts-ignore
+            if (schema.allOf[0].includes("circular")) {
+                return schema.allOf[0];
+            }
+        }
+        return "object";
+    }
+    if (schema.oneOf) {
+        return "object";
+    }
+    if (schema.anyOf) {
+        return "object";
+    }
+    if (schema.type === "object") {
+        return (_b = (_a = schema.xml) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : schema.type;
+        // return schema.type;
+    }
+    if (schema.type === "array") {
+        return (_d = (_c = schema.xml) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : schema.type;
+        // return schema.type;
+    }
+    if (schema.title && schema.type) {
+        return `${schema.title} (${schema.type})`;
+    }
+    return (_e = schema.title) !== null && _e !== void 0 ? _e : schema.type;
+}
+function getSchemaName(schema, circular) {
+    var _a;
+    if (schema.items) {
+        return prettyName(schema.items, 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/schema.test.d.ts

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

package/lib/markdown/schema.test.js

@@ -0,0 +1,181 @@
+"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 });
+const schema_1 = require("./schema");
+describe("getQualifierMessage", () => {
+    it("should render nothing", () => {
+        const actual = (0, schema_1.getQualifierMessage)({});
+        expect(actual).toBeUndefined();
+    });
+    //
+    // minLength + maxLength
+    //
+    it("should render minLength", () => {
+        const expected = "**Possible values:** `non-empty`";
+        const actual = (0, schema_1.getQualifierMessage)({ minLength: 1 });
+        expect(actual).toBe(expected);
+    });
+    it("should render maxLength", () => {
+        const expected = "**Possible values:** `<= 40 characters`";
+        const actual = (0, schema_1.getQualifierMessage)({ maxLength: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render minLength and maxLength", () => {
+        const expected = "**Possible values:** `non-empty` and `<= 40 characters`";
+        const actual = (0, schema_1.getQualifierMessage)({ minLength: 1, maxLength: 40 });
+        expect(actual).toBe(expected);
+    });
+    //
+    // pattern
+    //
+    it("should render pattern", () => {
+        const expected = "**Possible values:** Value must match regular expression `^[a-zA-Z0-9_-]*$`";
+        const actual = (0, schema_1.getQualifierMessage)({ pattern: "^[a-zA-Z0-9_-]*$" });
+        expect(actual).toBe(expected);
+    });
+    it("should render multiple string qualifiers", () => {
+        const expected = "**Possible values:** `non-empty` and `<= 40 characters`, Value must match regular expression `^[a-zA-Z0-9_-]*$`";
+        const actual = (0, schema_1.getQualifierMessage)({
+            minLength: 1,
+            maxLength: 40,
+            pattern: "^[a-zA-Z0-9_-]*$",
+        });
+        expect(actual).toBe(expected);
+    });
+    //
+    // enum
+    //
+    it("should render enum", () => {
+        const expected = "**Possible values:** [`cat`, `dog`, `mouse`]";
+        const actual = (0, schema_1.getQualifierMessage)({ enum: ["cat", "dog", "mouse"] });
+        expect(actual).toBe(expected);
+    });
+    //
+    // minimum + maximum + exclusiveMinimum + exclusiveMaximum
+    //
+    it("should render minimum", () => {
+        const expected = "**Possible values:** `>= 1`";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1 });
+        expect(actual).toBe(expected);
+    });
+    it("should render maximum", () => {
+        const expected = "**Possible values:** `<= 40`";
+        const actual = (0, schema_1.getQualifierMessage)({ maximum: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render numeric exclusiveMinimum", () => {
+        const expected = "**Possible values:** `> 1`";
+        const actual = (0, schema_1.getQualifierMessage)({ exclusiveMinimum: 1 });
+        expect(actual).toBe(expected);
+    });
+    it("should render numeric exclusiveMaximum", () => {
+        const expected = "**Possible values:** `< 40`";
+        const actual = (0, schema_1.getQualifierMessage)({ exclusiveMaximum: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render boolean exclusiveMinimum", () => {
+        const expected = "**Possible values:** `> 1`";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, exclusiveMinimum: true });
+        expect(actual).toBe(expected);
+    });
+    it("should render boolean exclusiveMaximum", () => {
+        const expected = "**Possible values:** `< 40`";
+        const actual = (0, schema_1.getQualifierMessage)({ maximum: 40, exclusiveMaximum: true });
+        expect(actual).toBe(expected);
+    });
+    it("should render minimum when exclusiveMinimum is false", () => {
+        const expected = "**Possible values:** `>= 1`";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, exclusiveMinimum: false });
+        expect(actual).toBe(expected);
+    });
+    it("should render maximum when exclusiveMaximum is false", () => {
+        const expected = "**Possible values:** `<= 40`";
+        const actual = (0, schema_1.getQualifierMessage)({
+            maximum: 40,
+            exclusiveMaximum: false,
+        });
+        expect(actual).toBe(expected);
+    });
+    it("should render minimum and maximum", () => {
+        const expected = "**Possible values:** `>= 1` and `<= 40`";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, maximum: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render 0 minimum and maximum", () => {
+        const expected = "**Possible values:** `>= 0` and `<= 40`";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: 0, maximum: 40 });
+        expect(actual).toBe(expected);
+    });
+    it("should render minimum and 0 maximum", () => {
+        const expected = "**Possible values:** `>= -10` and `<= 0`";
+        const actual = (0, schema_1.getQualifierMessage)({ minimum: -10, maximum: 0 });
+        expect(actual).toBe(expected);
+    });
+    it("should render boolean exclusiveMinimum and maximum", () => {
+        const expected = "**Possible values:** `> 1` and `<= 40`";
+        const actual = (0, schema_1.getQualifierMessage)({
+            minimum: 1,
+            maximum: 40,
+            exclusiveMinimum: true,
+        });
+        expect(actual).toBe(expected);
+    });
+    it("should render minimum and boolean exclusiveMaximum", () => {
+        const expected = "**Possible values:** `>= 1` and `< 40`";
+        const actual = (0, schema_1.getQualifierMessage)({
+            minimum: 1,
+            maximum: 40,
+            exclusiveMaximum: true,
+        });
+        expect(actual).toBe(expected);
+    });
+    it("should render numeric exclusiveMinimum and maximum", () => {
+        const expected = "**Possible values:** `> 1` and `<= 40`";
+        const actual = (0, schema_1.getQualifierMessage)({
+            exclusiveMinimum: 1,
+            maximum: 40,
+        });
+        expect(actual).toBe(expected);
+    });
+    it("should render minimum and numeric exclusiveMaximum", () => {
+        const expected = "**Possible values:** `>= 1` and `< 40`";
+        const actual = (0, schema_1.getQualifierMessage)({
+            minimum: 1,
+            exclusiveMaximum: 40,
+        });
+        expect(actual).toBe(expected);
+    });
+    it("should render numeric exclusiveMinimum and boolean exclusiveMaximum", () => {
+        const expected = "**Possible values:** `> 1` and `< 40`";
+        const actual = (0, schema_1.getQualifierMessage)({
+            exclusiveMinimum: 1,
+            maximum: 40,
+            exclusiveMaximum: true,
+        });
+        expect(actual).toBe(expected);
+    });
+    it("should render nothing with empty boolean exclusiveMinimum", () => {
+        const actual = (0, schema_1.getQualifierMessage)({
+            exclusiveMinimum: true,
+        });
+        expect(actual).toBeUndefined();
+    });
+    it("should render nothing with empty boolean exclusiveMaximum", () => {
+        const actual = (0, schema_1.getQualifierMessage)({
+            exclusiveMaximum: true,
+        });
+        expect(actual).toBeUndefined();
+    });
+    it("should render nothing with empty boolean exclusiveMinimum and exclusiveMaximum", () => {
+        const actual = (0, schema_1.getQualifierMessage)({
+            exclusiveMinimum: true,
+            exclusiveMaximum: true,
+        });
+        expect(actual).toBeUndefined();
+    });
+});

package/lib/markdown/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Children in the plugin does not accept DOM elements, when compared with Children in the theme.
+ * It is designed for rendering HTML a strings.
+ */
+export type Children = string | undefined | (string | string[] | undefined)[];
+export type Props = Record<string, any> & {
+    children?: Children;
+};
+export type Options = {
+    inline?: boolean;
+};
+export declare function create(tag: string, props: Props, options?: Options): string;
+export declare function guard<T>(value: T | undefined, cb: (value: T) => Children): string;
+export declare function render(children: Children): string;
+export declare const lessThan: RegExp;
+export declare const greaterThan: RegExp;
+export declare const codeFence: RegExp;
+export declare const curlyBrackets: RegExp;
+export declare const codeBlock: RegExp;
+export declare function clean(value: string | undefined): string;