docusaurus-plugin-openapi-docs 0.0.0-408 → 0.0.0-411

package/lib/markdown/createLogo.d.ts

@@ -0,0 +1,2 @@
+import { LogoObject } from "../openapi/types";
+export declare function createLogo(logo: LogoObject | undefined, darkLogo: LogoObject | undefined): string;

package/lib/markdown/createLogo.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.createLogo = void 0;
+const utils_1 = require("./utils");
+function createLogo(logo, darkLogo) {
+    return (0, utils_1.guard)(logo || darkLogo, () => [
+        (0, utils_1.create)("ApiLogo", {
+            logo: logo,
+            darkLogo: darkLogo,
+        }),
+    ]);
+}
+exports.createLogo = createLogo;

package/lib/markdown/index.d.ts

@@ -1,4 +1,4 @@
 import { ApiPageMetadata, InfoPageMetadata, TagPageMetadata } from "../types";
 export declare function createApiPageMD({ title, api: { deprecated, "x-deprecated-description": deprecatedDescription, description, parameters, requestBody, responses, }, }: ApiPageMetadata): string;
-export declare function createInfoPageMD({ info: { title, version, description, contact, license, termsOfService }, securitySchemes, }: InfoPageMetadata): string;
+export declare function createInfoPageMD({ info: { title, version, description, contact, license, termsOfService, logo, darkLogo, }, securitySchemes, }: InfoPageMetadata): string;
 export declare function createTagPageMD({ tag: { description } }: TagPageMetadata): string;

package/lib/markdown/index.js

@@ -13,6 +13,7 @@ const createContactInfo_1 = require("./createContactInfo");
 const createDeprecationNotice_1 = require("./createDeprecationNotice");
 const createDescription_1 = require("./createDescription");
 const createLicense_1 = require("./createLicense");
+const createLogo_1 = require("./createLogo");
 const createParamsDetails_1 = require("./createParamsDetails");
 const createRequestBodyDetails_1 = require("./createRequestBodyDetails");
 const createStatusCodes_1 = require("./createStatusCodes");
@@ -39,12 +40,14 @@ function createApiPageMD({ title, api: { deprecated, "x-deprecated-description":
     ]);
 }
 exports.createApiPageMD = createApiPageMD;
-function createInfoPageMD({ info: { title, version, description, contact, license, termsOfService }, securitySchemes, }) {
+function createInfoPageMD({ info: { title, version, description, contact, license, termsOfService, logo, darkLogo, }, securitySchemes, }) {
     return (0, utils_1.render)([
+        `import ApiLogo from "@theme/ApiLogo";\n`,
         `import Tabs from "@theme/Tabs";\n`,
         `import TabItem from "@theme/TabItem";\n\n`,
         (0, createVersionBadge_1.createVersionBadge)(version),
         `# ${(0, lodash_1.escape)(title)}\n\n`,
+        (0, createLogo_1.createLogo)(logo, darkLogo),
         (0, createDescription_1.createDescription)(description),
         (0, createAuthentication_1.createAuthentication)(securitySchemes),
         (0, createContactInfo_1.createContactInfo)(contact),

package/lib/markdown/schema.js

@@ -61,12 +61,25 @@ function getQualifierMessage(schema) {
     let qualifierGroups = [];
     if (schema.minLength || schema.maxLength) {
         let lengthQualifier = "";
-        if (schema.minLength) {
-            lengthQualifier += `${schema.minLength} ≤ `;
+        let minLength;
+        let maxLength;
+        if (schema.minLength && schema.minLength > 1) {
+            minLength = `\`>= ${schema.minLength} characters\``;
+        }
+        if (schema.minLength && schema.minLength === 1) {
+            minLength = `\`non-empty\``;
         }
-        lengthQualifier += "length";
         if (schema.maxLength) {
-            lengthQualifier += ` ≤ ${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);
     }
@@ -75,24 +88,34 @@ function getQualifierMessage(schema) {
         typeof schema.exclusiveMinimum === "number" ||
         typeof schema.exclusiveMaximum === "number") {
         let minmaxQualifier = "";
+        let minimum;
+        let maximum;
         if (typeof schema.exclusiveMinimum === "number") {
-            minmaxQualifier += `${schema.exclusiveMinimum} < `;
+            minimum = `\`> ${schema.exclusiveMinimum}\``;
         }
         else if (schema.minimum && !schema.exclusiveMinimum) {
-            minmaxQualifier += `${schema.minimum} ≤ `;
+            minimum = `\`>= ${schema.minimum}\``;
         }
         else if (schema.minimum && schema.exclusiveMinimum === true) {
-            minmaxQualifier += `${schema.minimum} < `;
+            minimum = `\`> ${schema.minimum}\``;
         }
-        minmaxQualifier += "value";
         if (typeof schema.exclusiveMaximum === "number") {
-            minmaxQualifier += ` < ${schema.exclusiveMaximum}`;
+            maximum = `\`< ${schema.exclusiveMaximum}\``;
         }
         else if (schema.maximum && !schema.exclusiveMaximum) {
-            minmaxQualifier += ` ≤ ${schema.maximum}`;
+            maximum = `\`<= ${schema.maximum}\``;
         }
         else if (schema.maximum && schema.exclusiveMaximum === true) {
-            minmaxQualifier += ` < ${schema.maximum}`;
+            maximum = `\`< ${schema.maximum}\``;
+        }
+        if (minimum && !maximum) {
+            minmaxQualifier += minimum;
+        }
+        if (maximum && !minimum) {
+            minmaxQualifier += maximum;
+        }
+        if (minimum && maximum) {
+            minmaxQualifier += `${minimum} and ${maximum}`;
         }
         qualifierGroups.push(minmaxQualifier);
     }
@@ -109,10 +132,10 @@ function getQualifierMessage(schema) {
         qualifierGroups.push(`[${schema.enum.map((e) => `\`${e}\``).join(", ")}]`);
     }
     if (schema.minItems) {
-        qualifierGroups.push(`items >= ${schema.minItems}`);
+        qualifierGroups.push(`\`>= ${schema.minItems}\``);
     }
     if (schema.maxItems) {
-        qualifierGroups.push(`items <= ${schema.maxItems}`);
+        qualifierGroups.push(`\`<= ${schema.maxItems}\``);
     }
     if (qualifierGroups.length === 0) {
         return undefined;

package/lib/markdown/schema.test.js

@@ -16,17 +16,17 @@ describe("getQualifierMessage", () => {
     // minLength + maxLength
     //
     it("should render minLength", () => {
-        const expected = "**Possible values:** 1 ≤ length";
+        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:** length ≤ 40";
+        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:** 1 ≤ length ≤ 40";
+        const expected = "**Possible values:** `non-empty` and `<= 40 characters`";
         const actual = (0, schema_1.getQualifierMessage)({ minLength: 1, maxLength: 40 });
         expect(actual).toBe(expected);
     });
@@ -39,7 +39,7 @@ describe("getQualifierMessage", () => {
         expect(actual).toBe(expected);
     });
     it("should render multiple string qualifiers", () => {
-        const expected = "**Possible values:** 1 ≤ length ≤ 40, Value must match regular expression `^[a-zA-Z0-9_-]*$`";
+        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,
@@ -59,42 +59,42 @@ describe("getQualifierMessage", () => {
     // minimum + maximum + exclusiveMinimum + exclusiveMaximum
     //
     it("should render minimum", () => {
-        const expected = "**Possible values:** 1 ≤ value";
+        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:** value ≤ 40";
+        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 < value";
+        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:** value < 40";
+        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 < value";
+        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:** value < 40";
+        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 ≤ value";
+        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:** value ≤ 40";
+        const expected = "**Possible values:** `<= 40`";
         const actual = (0, schema_1.getQualifierMessage)({
             maximum: 40,
             exclusiveMaximum: false,
@@ -102,12 +102,12 @@ describe("getQualifierMessage", () => {
         expect(actual).toBe(expected);
     });
     it("should render minimum and maximum", () => {
-        const expected = "**Possible values:** 1 ≤ value ≤ 40";
+        const expected = "**Possible values:** `>= 1` and `<= 40`";
         const actual = (0, schema_1.getQualifierMessage)({ minimum: 1, maximum: 40 });
         expect(actual).toBe(expected);
     });
     it("should render boolean exclusiveMinimum and maximum", () => {
-        const expected = "**Possible values:** 1 < value ≤ 40";
+        const expected = "**Possible values:** `> 1` and `<= 40`";
         const actual = (0, schema_1.getQualifierMessage)({
             minimum: 1,
             maximum: 40,
@@ -116,7 +116,7 @@ describe("getQualifierMessage", () => {
         expect(actual).toBe(expected);
     });
     it("should render minimum and boolean exclusiveMaximum", () => {
-        const expected = "**Possible values:** 1 ≤ value < 40";
+        const expected = "**Possible values:** `>= 1` and `< 40`";
         const actual = (0, schema_1.getQualifierMessage)({
             minimum: 1,
             maximum: 40,
@@ -125,7 +125,7 @@ describe("getQualifierMessage", () => {
         expect(actual).toBe(expected);
     });
     it("should render numeric exclusiveMinimum and maximum", () => {
-        const expected = "**Possible values:** 1 < value ≤ 40";
+        const expected = "**Possible values:** `> 1` and `<= 40`";
         const actual = (0, schema_1.getQualifierMessage)({
             exclusiveMinimum: 1,
             maximum: 40,
@@ -133,7 +133,7 @@ describe("getQualifierMessage", () => {
         expect(actual).toBe(expected);
     });
     it("should render minimum and numeric exclusiveMaximum", () => {
-        const expected = "**Possible values:** 1 ≤ value < 40";
+        const expected = "**Possible values:** `>= 1` and `< 40`";
         const actual = (0, schema_1.getQualifierMessage)({
             minimum: 1,
             exclusiveMaximum: 40,
@@ -141,7 +141,7 @@ describe("getQualifierMessage", () => {
         expect(actual).toBe(expected);
     });
     it("should render numeric exclusiveMinimum and boolean exclusiveMaximum", () => {
-        const expected = "**Possible values:** 1 < value < 40";
+        const expected = "**Possible values:** `> 1` and `< 40`";
         const actual = (0, schema_1.getQualifierMessage)({
             exclusiveMinimum: 1,
             maximum: 40,

package/lib/openapi/openapi.js

@@ -16,7 +16,8 @@ const openapi_to_postmanv2_1 = __importDefault(require("@paloaltonetworks/openap
 const postman_collection_1 = __importDefault(require("@paloaltonetworks/postman-collection"));
 const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const lodash_1 = require("lodash");
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const kebabCase_1 = __importDefault(require("lodash/kebabCase"));
 const index_1 = require("../index");
 const createExample_1 = require("./createExample");
 const loadAndResolveSpec_1 = require("./utils/loadAndResolveSpec");
@@ -41,7 +42,7 @@ function jsonToCollection(data) {
 async function createPostmanCollection(openapiData) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     // Create copy of openapiData
-    const data = Object.assign({}, openapiData);
+    const data = (0, cloneDeep_1.default)(openapiData);
     // Including `servers` breaks postman, so delete all of them.
     delete data.servers;
     for (let pathItemObject of Object.values(data.paths)) {
@@ -61,7 +62,7 @@ function createItems(openapiData, sidebarOptions) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
     // TODO: Find a better way to handle this
     let items = [];
-    const infoId = (0, lodash_1.kebabCase)(openapiData.info.title);
+    const infoId = (0, kebabCase_1.default)(openapiData.info.title);
     if ((sidebarOptions === null || sidebarOptions === void 0 ? void 0 : sidebarOptions.categoryLinkSource) === "tag") {
         // Only create an tag pages if categoryLinkSource set to tag.
         const tags = (_a = openapiData.tags) !== null && _a !== void 0 ? _a : [];
@@ -72,7 +73,7 @@ function createItems(openapiData, sidebarOptions) {
             .map((tag) => {
             var _a;
             const description = getTagDisplayName(tag.name, (_a = openapiData.tags) !== null && _a !== void 0 ? _a : []);
-            const tagId = (0, lodash_1.kebabCase)(tag.name);
+            const tagId = (0, kebabCase_1.default)(tag.name);
             const tagPage = {
                 type: "tag",
                 id: tagId,
@@ -101,6 +102,8 @@ function createItems(openapiData, sidebarOptions) {
                 ...openapiData.info,
                 tags: (_c = openapiData.tags) === null || _c === void 0 ? void 0 : _c.map((tagName) => { var _a; return getTagDisplayName(tagName.name, (_a = openapiData.tags) !== null && _a !== void 0 ? _a : []); }),
                 title: (_d = openapiData.info.title) !== null && _d !== void 0 ? _d : "Introduction",
+                logo: openapiData.info["x-logo"],
+                darkLogo: openapiData.info["x-dark-logo"],
             },
         };
         items.push(infoPage);
@@ -114,8 +117,8 @@ function createItems(openapiData, sidebarOptions) {
                     (_h = (_g = operationObject.summary) !== null && _g !== void 0 ? _g : operationObject.operationId) !== null && _h !== void 0 ? _h : "";
             }
             const baseId = operationObject.operationId
-                ? (0, lodash_1.kebabCase)(operationObject.operationId)
-                : (0, lodash_1.kebabCase)(operationObject.summary);
+                ? (0, kebabCase_1.default)(operationObject.operationId)
+                : (0, kebabCase_1.default)(operationObject.summary);
             const servers = (_k = (_j = operationObject.servers) !== null && _j !== void 0 ? _j : pathObject.servers) !== null && _k !== void 0 ? _k : openapiData.servers;
             const security = (_l = operationObject.security) !== null && _l !== void 0 ? _l : openapiData.security;
             // Add security schemes so we know how to handle security.

package/lib/openapi/types.d.ts

@@ -31,6 +31,13 @@ export interface InfoObject {
     license?: LicenseObject;
     version: string;
     tags?: String[];
+    "x-logo"?: LogoObject;
+    "x-dark-logo"?: LogoObject;
+    logo?: LogoObject;
+    darkLogo?: LogoObject;
+}
+export interface LogoObject {
+    url?: string;
 }
 export interface ContactObject {
     name?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-plugin-openapi-docs",
   "description": "OpenAPI plugin for Docusaurus.",
-  "version": "0.0.0-408",
+  "version": "0.0.0-411",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -67,5 +67,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "a13982ebd24d40f4a81ba75a7f1046682b2ba49b"
+  "gitHead": "f3967eda19d631760dc9e7f9e5a358897964f0a7"
 }

package/src/markdown/createLogo.ts

@@ -0,0 +1,21 @@
+/* ============================================================================
+ * 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.
+ * ========================================================================== */
+
+import { LogoObject } from "../openapi/types";
+import { create, guard } from "./utils";
+
+export function createLogo(
+  logo: LogoObject | undefined,
+  darkLogo: LogoObject | undefined
+) {
+  return guard(logo || darkLogo, () => [
+    create("ApiLogo", {
+      logo: logo,
+      darkLogo: darkLogo,
+    }),
+  ]);
+}

package/src/markdown/index.ts

@@ -18,6 +18,7 @@ import { createContactInfo } from "./createContactInfo";
 import { createDeprecationNotice } from "./createDeprecationNotice";
 import { createDescription } from "./createDescription";
 import { createLicense } from "./createLicense";
+import { createLogo } from "./createLogo";
 import { createParamsDetails } from "./createParamsDetails";
 import { createRequestBodyDetails } from "./createRequestBodyDetails";
 import { createStatusCodes } from "./createStatusCodes";
@@ -56,14 +57,26 @@ export function createApiPageMD({
 }
 
 export function createInfoPageMD({
-  info: { title, version, description, contact, license, termsOfService },
+  info: {
+    title,
+    version,
+    description,
+    contact,
+    license,
+    termsOfService,
+    logo,
+    darkLogo,
+  },
   securitySchemes,
 }: InfoPageMetadata) {
   return render([
+    `import ApiLogo from "@theme/ApiLogo";\n`,
     `import Tabs from "@theme/Tabs";\n`,
     `import TabItem from "@theme/TabItem";\n\n`,
+
     createVersionBadge(version),
     `# ${escape(title)}\n\n`,
+    createLogo(logo, darkLogo),
     createDescription(description),
     createAuthentication(securitySchemes as unknown as SecuritySchemeObject),
     createContactInfo(contact as ContactObject),

package/src/markdown/schema.test.ts

@@ -17,19 +17,19 @@ describe("getQualifierMessage", () => {
   // minLength + maxLength
   //
   it("should render minLength", () => {
-    const expected = "**Possible values:** 1 ≤ length";
+    const expected = "**Possible values:** `non-empty`";
     const actual = getQualifierMessage({ minLength: 1 });
     expect(actual).toBe(expected);
   });
 
   it("should render maxLength", () => {
-    const expected = "**Possible values:** length ≤ 40";
+    const expected = "**Possible values:** `<= 40 characters`";
     const actual = getQualifierMessage({ maxLength: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render minLength and maxLength", () => {
-    const expected = "**Possible values:** 1 ≤ length ≤ 40";
+    const expected = "**Possible values:** `non-empty` and `<= 40 characters`";
     const actual = getQualifierMessage({ minLength: 1, maxLength: 40 });
     expect(actual).toBe(expected);
   });
@@ -46,7 +46,7 @@ describe("getQualifierMessage", () => {
 
   it("should render multiple string qualifiers", () => {
     const expected =
-      "**Possible values:** 1 ≤ length ≤ 40, Value must match regular expression `^[a-zA-Z0-9_-]*$`";
+      "**Possible values:** `non-empty` and `<= 40 characters`, Value must match regular expression `^[a-zA-Z0-9_-]*$`";
     const actual = getQualifierMessage({
       minLength: 1,
       maxLength: 40,
@@ -68,49 +68,49 @@ describe("getQualifierMessage", () => {
   // minimum + maximum + exclusiveMinimum + exclusiveMaximum
   //
   it("should render minimum", () => {
-    const expected = "**Possible values:** 1 ≤ value";
+    const expected = "**Possible values:** `>= 1`";
     const actual = getQualifierMessage({ minimum: 1 });
     expect(actual).toBe(expected);
   });
 
   it("should render maximum", () => {
-    const expected = "**Possible values:** value ≤ 40";
+    const expected = "**Possible values:** `<= 40`";
     const actual = getQualifierMessage({ maximum: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render numeric exclusiveMinimum", () => {
-    const expected = "**Possible values:** 1 < value";
+    const expected = "**Possible values:** `> 1`";
     const actual = getQualifierMessage({ exclusiveMinimum: 1 });
     expect(actual).toBe(expected);
   });
 
   it("should render numeric exclusiveMaximum", () => {
-    const expected = "**Possible values:** value < 40";
+    const expected = "**Possible values:** `< 40`";
     const actual = getQualifierMessage({ exclusiveMaximum: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render boolean exclusiveMinimum", () => {
-    const expected = "**Possible values:** 1 < value";
+    const expected = "**Possible values:** `> 1`";
     const actual = getQualifierMessage({ minimum: 1, exclusiveMinimum: true });
     expect(actual).toBe(expected);
   });
 
   it("should render boolean exclusiveMaximum", () => {
-    const expected = "**Possible values:** value < 40";
+    const expected = "**Possible values:** `< 40`";
     const actual = getQualifierMessage({ maximum: 40, exclusiveMaximum: true });
     expect(actual).toBe(expected);
   });
 
   it("should render minimum when exclusiveMinimum is false", () => {
-    const expected = "**Possible values:** 1 ≤ value";
+    const expected = "**Possible values:** `>= 1`";
     const actual = getQualifierMessage({ minimum: 1, exclusiveMinimum: false });
     expect(actual).toBe(expected);
   });
 
   it("should render maximum when exclusiveMaximum is false", () => {
-    const expected = "**Possible values:** value ≤ 40";
+    const expected = "**Possible values:** `<= 40`";
     const actual = getQualifierMessage({
       maximum: 40,
       exclusiveMaximum: false,
@@ -119,13 +119,13 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render minimum and maximum", () => {
-    const expected = "**Possible values:** 1 ≤ value ≤ 40";
+    const expected = "**Possible values:** `>= 1` and `<= 40`";
     const actual = getQualifierMessage({ minimum: 1, maximum: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render boolean exclusiveMinimum and maximum", () => {
-    const expected = "**Possible values:** 1 < value ≤ 40";
+    const expected = "**Possible values:** `> 1` and `<= 40`";
     const actual = getQualifierMessage({
       minimum: 1,
       maximum: 40,
@@ -135,7 +135,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render minimum and boolean exclusiveMaximum", () => {
-    const expected = "**Possible values:** 1 ≤ value < 40";
+    const expected = "**Possible values:** `>= 1` and `< 40`";
     const actual = getQualifierMessage({
       minimum: 1,
       maximum: 40,
@@ -145,7 +145,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render numeric exclusiveMinimum and maximum", () => {
-    const expected = "**Possible values:** 1 < value ≤ 40";
+    const expected = "**Possible values:** `> 1` and `<= 40`";
     const actual = getQualifierMessage({
       exclusiveMinimum: 1,
       maximum: 40,
@@ -154,7 +154,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render minimum and numeric exclusiveMaximum", () => {
-    const expected = "**Possible values:** 1 ≤ value < 40";
+    const expected = "**Possible values:** `>= 1` and `< 40`";
     const actual = getQualifierMessage({
       minimum: 1,
       exclusiveMaximum: 40,
@@ -163,7 +163,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render numeric exclusiveMinimum and boolean exclusiveMaximum", () => {
-    const expected = "**Possible values:** 1 < value < 40";
+    const expected = "**Possible values:** `> 1` and `< 40`";
     const actual = getQualifierMessage({
       exclusiveMinimum: 1,
       maximum: 40,

package/src/markdown/schema.ts

@@ -74,13 +74,28 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
 
   if (schema.minLength || schema.maxLength) {
     let lengthQualifier = "";
-    if (schema.minLength) {
-      lengthQualifier += `${schema.minLength} ≤ `;
+    let minLength;
+    let maxLength;
+    if (schema.minLength && schema.minLength > 1) {
+      minLength = `\`>= ${schema.minLength} characters\``;
+    }
+    if (schema.minLength && schema.minLength === 1) {
+      minLength = `\`non-empty\``;
     }
-    lengthQualifier += "length";
     if (schema.maxLength) {
-      lengthQualifier += ` ≤ ${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);
   }
 
@@ -91,21 +106,33 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
     typeof schema.exclusiveMaximum === "number"
   ) {
     let minmaxQualifier = "";
+    let minimum;
+    let maximum;
     if (typeof schema.exclusiveMinimum === "number") {
-      minmaxQualifier += `${schema.exclusiveMinimum} < `;
+      minimum = `\`> ${schema.exclusiveMinimum}\``;
     } else if (schema.minimum && !schema.exclusiveMinimum) {
-      minmaxQualifier += `${schema.minimum} ≤ `;
+      minimum = `\`>= ${schema.minimum}\``;
     } else if (schema.minimum && schema.exclusiveMinimum === true) {
-      minmaxQualifier += `${schema.minimum} < `;
+      minimum = `\`> ${schema.minimum}\``;
     }
-    minmaxQualifier += "value";
     if (typeof schema.exclusiveMaximum === "number") {
-      minmaxQualifier += ` < ${schema.exclusiveMaximum}`;
+      maximum = `\`< ${schema.exclusiveMaximum}\``;
     } else if (schema.maximum && !schema.exclusiveMaximum) {
-      minmaxQualifier += ` ≤ ${schema.maximum}`;
+      maximum = `\`<= ${schema.maximum}\``;
     } else if (schema.maximum && schema.exclusiveMaximum === true) {
-      minmaxQualifier += ` < ${schema.maximum}`;
+      maximum = `\`< ${schema.maximum}\``;
     }
+
+    if (minimum && !maximum) {
+      minmaxQualifier += minimum;
+    }
+    if (maximum && !minimum) {
+      minmaxQualifier += maximum;
+    }
+    if (minimum && maximum) {
+      minmaxQualifier += `${minimum} and ${maximum}`;
+    }
+
     qualifierGroups.push(minmaxQualifier);
   }
 
@@ -127,11 +154,11 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
   }
 
   if (schema.minItems) {
-    qualifierGroups.push(`items >= ${schema.minItems}`);
+    qualifierGroups.push(`\`>= ${schema.minItems}\``);
   }
 
   if (schema.maxItems) {
-    qualifierGroups.push(`items <= ${schema.maxItems}`);
+    qualifierGroups.push(`\`<= ${schema.maxItems}\``);
   }
 
   if (qualifierGroups.length === 0) {

package/src/openapi/openapi.ts

@@ -13,7 +13,8 @@ import sdk from "@paloaltonetworks/postman-collection";
 import Collection from "@paloaltonetworks/postman-collection";
 import chalk from "chalk";
 import fs from "fs-extra";
-import { kebabCase } from "lodash";
+import cloneDeep from "lodash/cloneDeep";
+import kebabCase from "lodash/kebabCase";
 
 import { isURL } from "../index";
 import {
@@ -54,7 +55,7 @@ async function createPostmanCollection(
   openapiData: OpenApiObject
 ): Promise<Collection> {
   // Create copy of openapiData
-  const data = Object.assign({}, openapiData) as OpenApiObject;
+  const data = cloneDeep(openapiData) as OpenApiObject;
 
   // Including `servers` breaks postman, so delete all of them.
   delete data.servers;
@@ -127,6 +128,8 @@ function createItems(
           getTagDisplayName(tagName.name!, openapiData.tags ?? [])
         ),
         title: openapiData.info.title ?? "Introduction",
+        logo: openapiData.info["x-logo"]! as any,
+        darkLogo: openapiData.info["x-dark-logo"]! as any,
       },
     };
     items.push(infoPage);

package/src/openapi/types.ts

@@ -42,6 +42,14 @@ export interface InfoObject {
   license?: LicenseObject;
   version: string;
   tags?: String[];
+  "x-logo"?: LogoObject;
+  "x-dark-logo"?: LogoObject;
+  logo?: LogoObject;
+  darkLogo?: LogoObject;
+}
+
+export interface LogoObject {
+  url?: string;
 }
 
 export interface ContactObject {