docusaurus-plugin-openapi-docs 1.1.2 → 1.1.3

package/README.md

@@ -246,7 +246,7 @@ yarn docusaurus gen-api-docs:version petstore:all
 Run the following to bootstrap a Docsaurus v2 site (classic theme) with `docusaurus-openapi-docs`:
 
 ```bash
-npx create-docusaurus@2.0.0-rc.1 my-website --package-manager yarn
+npx create-docusaurus@2.0.1 my-website --package-manager yarn
 ```
 
 > When prompted to select a template choose `Git repository`.

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/createSchemaDetails.js

@@ -86,12 +86,14 @@ function createAnyOneOf(schema) {
     });
 }
 function createProperties(schema) {
+    const discriminator = schema.discriminator;
     return Object.entries(schema.properties).map(([key, val]) => createEdges({
         name: key,
         schema: val,
         required: Array.isArray(schema.required)
             ? schema.required.includes(key)
             : false,
+        discriminator,
     }));
 }
 function createAdditionalProperties(schema) {
@@ -228,6 +230,93 @@ function createItems(schema) {
             : false,
     }));
 }
+/**
+ * For handling discriminators that do not map to a same-level property
+ */
+function createDiscriminator(schema) {
+    var _a;
+    const discriminator = schema.discriminator;
+    const propertyName = discriminator === null || discriminator === void 0 ? void 0 : discriminator.propertyName;
+    const propertyType = "string"; // should always be string
+    const mapping = discriminator === null || discriminator === void 0 ? void 0 : discriminator.mapping;
+    // Explicit mapping is required since we can't support implicit
+    if (mapping === undefined) {
+        return undefined;
+    }
+    // Attempt to get the property description we want to display
+    // TODO: how to make it predictable when handling allOf
+    let propertyDescription;
+    const firstMappingSchema = mapping[Object.keys(mapping)[0]];
+    if (firstMappingSchema.properties !== undefined) {
+        propertyDescription =
+            firstMappingSchema.properties[propertyName].description;
+    }
+    if (firstMappingSchema.allOf !== undefined) {
+        const { mergedSchemas } = mergeAllOf(firstMappingSchema.allOf);
+        if (mergedSchemas.properties !== undefined) {
+            propertyDescription =
+                (_a = mergedSchemas.properties[propertyName]) === null || _a === void 0 ? void 0 : _a.description;
+        }
+    }
+    if (propertyDescription === undefined) {
+        if (schema.properties !== undefined &&
+            schema.properties[propertyName] !== undefined) {
+            propertyDescription = schema.properties[propertyName].description;
+        }
+    }
+    return (0, utils_1.create)("div", {
+        className: "discriminatorItem",
+        children: (0, utils_1.create)("div", {
+            children: [
+                (0, utils_1.create)("strong", {
+                    style: { paddingLeft: "1rem" },
+                    children: propertyName,
+                }),
+                (0, utils_1.guard)(propertyType, (name) => (0, utils_1.create)("span", {
+                    style: { opacity: "0.6" },
+                    children: ` ${propertyType}`,
+                })),
+                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(schema.discriminator), (message) => (0, utils_1.create)("div", {
+                    style: {
+                        paddingLeft: "1rem",
+                    },
+                    children: (0, createDescription_1.createDescription)(message),
+                })),
+                (0, utils_1.guard)(propertyDescription, (description) => (0, utils_1.create)("div", {
+                    style: {
+                        paddingLeft: "1rem",
+                    },
+                    children: (0, createDescription_1.createDescription)(description),
+                })),
+                (0, utils_1.create)("DiscriminatorTabs", {
+                    children: Object.keys(mapping).map((key, index) => {
+                        if (mapping[key].allOf !== undefined) {
+                            const { mergedSchemas } = mergeAllOf(mapping[key].allOf);
+                            // Cleanup duplicate property from mapping schema
+                            delete mergedSchemas.properties[propertyName];
+                            mapping[key] = mergedSchemas;
+                        }
+                        if (mapping[key].properties !== undefined) {
+                            // Cleanup duplicate property from mapping schema
+                            delete mapping[key].properties[propertyName];
+                        }
+                        const label = key;
+                        return (0, utils_1.create)("TabItem", {
+                            label: label,
+                            value: `${index}-item-discriminator`,
+                            children: [
+                                (0, utils_1.create)("div", {
+                                    style: { marginLeft: "-4px" },
+                                    children: createNodes(mapping[key]),
+                                }),
+                            ],
+                        });
+                    }),
+                }),
+            ],
+        }),
+    });
+}
 function createDetailsNode(name, schemaName, schema, required) {
     return (0, utils_1.create)("SchemaItem", {
         collapsible: true,
@@ -272,12 +361,75 @@ function createDetailsNode(name, schemaName, schema, required) {
         ],
     });
 }
+/**
+ * For handling discriminators that map to a same-level property (like 'petType').
+ * Note: These should only be encountered while iterating through properties.
+ */
+function createPropertyDiscriminator(name, schemaName, schema, discriminator, required) {
+    if (schema === undefined) {
+        return undefined;
+    }
+    if (discriminator.mapping === undefined) {
+        return undefined;
+    }
+    return (0, utils_1.create)("div", {
+        className: "discriminatorItem",
+        children: (0, utils_1.create)("div", {
+            children: [
+                (0, utils_1.create)("strong", { style: { paddingLeft: "1rem" }, children: name }),
+                (0, utils_1.guard)(schemaName, (name) => (0, utils_1.create)("span", {
+                    style: { opacity: "0.6" },
+                    children: ` ${schemaName}`,
+                })),
+                (0, utils_1.guard)(required, () => [
+                    (0, utils_1.create)("strong", {
+                        style: {
+                            fontSize: "var(--ifm-code-font-size)",
+                            color: "var(--openapi-required)",
+                        },
+                        children: " required",
+                    }),
+                ]),
+                (0, utils_1.guard)((0, schema_1.getQualifierMessage)(discriminator), (message) => (0, utils_1.create)("div", {
+                    style: {
+                        paddingLeft: "1rem",
+                    },
+                    children: (0, createDescription_1.createDescription)(message),
+                })),
+                (0, utils_1.guard)(schema.description, (description) => (0, utils_1.create)("div", {
+                    style: {
+                        paddingLeft: "1rem",
+                    },
+                    children: (0, createDescription_1.createDescription)(description),
+                })),
+                (0, utils_1.create)("DiscriminatorTabs", {
+                    children: Object.keys(discriminator === null || discriminator === void 0 ? void 0 : discriminator.mapping).map((key, index) => {
+                        const label = key;
+                        return (0, utils_1.create)("TabItem", {
+                            label: label,
+                            value: `${index}-item-discriminator`,
+                            children: [
+                                (0, utils_1.create)("div", {
+                                    style: { marginLeft: "-4px" },
+                                    children: createNodes(discriminator === null || discriminator === void 0 ? void 0 : discriminator.mapping[key]),
+                                }),
+                            ],
+                        });
+                    }),
+                }),
+            ],
+        }),
+    });
+}
 /**
  * Creates the edges or "leaves" of a schema tree. Edges can branch into sub-nodes with createDetails().
  */
-function createEdges({ name, schema, required }) {
+function createEdges({ name, schema, required, discriminator, }) {
     var _a;
     const schemaName = (0, schema_1.getSchemaName)(schema);
+    if (discriminator !== undefined && discriminator.propertyName === name) {
+        return createPropertyDiscriminator(name, "string", schema, discriminator, required);
+    }
     if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
         return createDetailsNode(name, schemaName, schema, required);
     }
@@ -327,6 +479,9 @@ function createEdges({ name, schema, required }) {
  * Creates a hierarchical level of a schema tree. Nodes produce edges that can branch into sub-nodes with edges, recursively.
  */
 function createNodes(schema) {
+    if (schema.discriminator !== undefined) {
+        return createDiscriminator(schema);
+    }
     if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
         return createAnyOneOf(schema);
     }

package/lib/markdown/createStatusCodes.js

@@ -8,8 +8,66 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatusCodes = void 0;
 const createDescription_1 = require("./createDescription");
+const createDetails_1 = require("./createDetails");
+const createDetailsSummary_1 = require("./createDetailsSummary");
 const createSchemaDetails_1 = require("./createSchemaDetails");
 const utils_1 = require("./utils");
+const utils_2 = require("./utils");
+function createResponseHeaders(responseHeaders) {
+    return (0, utils_2.guard)(responseHeaders, () => (0, utils_1.create)("ul", {
+        style: { marginLeft: "1rem" },
+        children: [
+            Object.entries(responseHeaders).map(([headerName, headerObj]) => {
+                const { description, schema: { type }, example, } = headerObj;
+                return (0, utils_1.create)("li", {
+                    class: "schemaItem",
+                    children: [
+                        (0, createDetailsSummary_1.createDetailsSummary)({
+                            children: [
+                                (0, utils_1.create)("strong", { children: headerName }),
+                                (0, utils_2.guard)(type, () => [
+                                    (0, utils_1.create)("span", {
+                                        style: { opacity: "0.6" },
+                                        children: ` ${type}`,
+                                    }),
+                                ]),
+                            ],
+                        }),
+                        (0, utils_1.create)("div", {
+                            children: [
+                                (0, utils_2.guard)(description, (description) => (0, utils_1.create)("div", {
+                                    style: {
+                                        marginTop: ".5rem",
+                                        marginBottom: ".5rem",
+                                    },
+                                    children: [
+                                        (0, utils_2.guard)(example, () => `Example: ${example}`),
+                                        (0, createDescription_1.createDescription)(description),
+                                    ],
+                                })),
+                            ],
+                        }),
+                    ],
+                });
+            }),
+        ],
+    }));
+}
+function createResponseExamples(responseExamples) {
+    return Object.entries(responseExamples).map(([exampleName, exampleValue]) => {
+        const camelToSpaceName = exampleName.replace(/([A-Z])/g, " $1");
+        let finalFormattedName = camelToSpaceName.charAt(0).toUpperCase() + camelToSpaceName.slice(1);
+        return (0, utils_1.create)("TabItem", {
+            label: `${finalFormattedName}`,
+            value: `${finalFormattedName}`,
+            children: [
+                (0, utils_1.create)("ResponseSamples", {
+                    responseExample: JSON.stringify(exampleValue.value, null, 2),
+                }),
+            ],
+        });
+    });
+}
 function createStatusCodes({ responses }) {
     if (responses === undefined) {
         return undefined;
@@ -22,6 +80,10 @@ function createStatusCodes({ responses }) {
         children: [
             (0, utils_1.create)("ApiTabs", {
                 children: codes.map((code) => {
+                    const responseHeaders = responses[code].headers;
+                    const responseContent = responses[code].content;
+                    const responseContentKey = responseContent && Object.keys(responseContent)[0];
+                    const responseExamples = responseContentKey && responseContent[responseContentKey].examples;
                     return (0, utils_1.create)("TabItem", {
                         label: code,
                         value: code,
@@ -29,14 +91,62 @@ function createStatusCodes({ responses }) {
                             (0, utils_1.create)("div", {
                                 children: (0, createDescription_1.createDescription)(responses[code].description),
                             }),
-                            (0, utils_1.create)("div", {
+                            (0, utils_2.guard)(responseExamples, () => (0, utils_1.create)("SchemaTabs", {
+                                children: [
+                                    (0, utils_1.create)("TabTtem", {
+                                        label: "Schema",
+                                        value: "Schema",
+                                        children: [
+                                            responseHeaders &&
+                                                (0, createDetails_1.createDetails)({
+                                                    "data-collaposed": false,
+                                                    open: true,
+                                                    style: { textAlign: "left" },
+                                                    children: [
+                                                        (0, createDetailsSummary_1.createDetailsSummary)({
+                                                            children: [
+                                                                (0, utils_1.create)("strong", {
+                                                                    children: "Response Headers",
+                                                                }),
+                                                            ],
+                                                        }),
+                                                        createResponseHeaders(responseHeaders),
+                                                    ],
+                                                }),
+                                            (0, utils_1.create)("div", {
+                                                children: (0, createSchemaDetails_1.createSchemaDetails)({
+                                                    title: "Schema",
+                                                    body: {
+                                                        content: responses[code].content,
+                                                    },
+                                                }),
+                                            }),
+                                        ],
+                                    }),
+                                    createResponseExamples(responseExamples),
+                                ],
+                            })),
+                            (0, utils_2.guard)(responseHeaders, () => (0, createDetails_1.createDetails)({
+                                "data-collaposed": false,
+                                open: true,
+                                style: { textAlign: "left" },
+                                children: [
+                                    (0, createDetailsSummary_1.createDetailsSummary)({
+                                        children: [
+                                            (0, utils_1.create)("strong", { children: "Response Headers" }),
+                                        ],
+                                    }),
+                                    createResponseHeaders(responseHeaders),
+                                ],
+                            })),
+                            (0, utils_2.guard)(!responseExamples, () => (0, utils_1.create)("div", {
                                 children: (0, createSchemaDetails_1.createSchemaDetails)({
                                     title: "Schema",
                                     body: {
                                         content: responses[code].content,
                                     },
                                 }),
-                            }),
+                            })),
                         ],
                     });
                 }),

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");
@@ -21,10 +22,12 @@ const createVersionBadge_1 = require("./createVersionBadge");
 const utils_1 = require("./utils");
 function createApiPageMD({ title, api: { deprecated, "x-deprecated-description": deprecatedDescription, description, parameters, requestBody, responses, }, }) {
     return (0, utils_1.render)([
+        `import ApiTabs from "@theme/ApiTabs";\n`,
         `import ParamsItem from "@theme/ParamsItem";\n`,
+        `import ResponseSamples from "@theme/ResponseSamples";\n`,
         `import SchemaItem from "@theme/SchemaItem"\n`,
-        `import ApiTabs from "@theme/ApiTabs";\n`,
         `import SchemaTabs from "@theme/SchemaTabs";\n`,
+        `import DiscriminatorTabs from "@theme/DiscriminatorTabs";\n`,
         `import TabItem from "@theme/TabItem";\n\n`,
         `## ${(0, lodash_1.escape)(title)}\n\n`,
         (0, createDeprecationNotice_1.createDeprecationNotice)({ deprecated, description: deprecatedDescription }),
@@ -38,12 +41,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

@@ -54,19 +54,39 @@ function getQualifierMessage(schema) {
     if (!schema) {
         return undefined;
     }
-    if (schema.items) {
+    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 = "";
-        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,38 +95,54 @@ 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);
     }
     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(`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,