@scalar/workspace-store 0.12.0 → 0.14.0

package/dist/plugins.js

@@ -0,0 +1,107 @@
+import { isLocalRef } from "./helpers/general.js";
+const loadingStatus = () => {
+  return {
+    type: "lifecycle",
+    onResolveStart: (node) => {
+      node["$status"] = "loading";
+    },
+    onResolveError: (node) => {
+      node["$status"] = "error";
+    },
+    onResolveSuccess: (node) => {
+      delete node["$status"];
+    }
+  };
+};
+const externalValueResolver = () => {
+  return {
+    type: "lifecycle",
+    onAfterNodeProcess: async (node, context) => {
+      const externalValue = node["externalValue"];
+      const cache = context.resolutionCache;
+      if (typeof externalValue !== "string") {
+        return;
+      }
+      const loader = context.loaders.find((it) => it.validate(externalValue));
+      if (!loader) {
+        return;
+      }
+      if (!cache.has(externalValue)) {
+        cache.set(externalValue, loader.exec(externalValue));
+      }
+      const result = await cache.get(externalValue);
+      if (result?.ok) {
+        node["value"] = result.data;
+      }
+    }
+  };
+};
+const refsEverywhere = () => {
+  return {
+    type: "lifecycle",
+    onBeforeNodeProcess: async (node, context) => {
+      const { path, resolutionCache, parentNode } = context;
+      const ref = node["$ref"];
+      if (typeof ref !== "string") {
+        return;
+      }
+      if (!parentNode || !path.length) {
+        return;
+      }
+      const loader = context.loaders.find((it) => it.validate(ref));
+      if (!loader) {
+        return;
+      }
+      if (path[0] === "info") {
+        if (!resolutionCache.has(ref)) {
+          resolutionCache.set(ref, loader.exec(ref));
+        }
+        const result = await resolutionCache.get(ref);
+        if (result?.ok) {
+          parentNode[path.at(-1)] = result.data;
+        }
+      }
+    }
+  };
+};
+const restoreOriginalRefs = () => {
+  return {
+    type: "lifecycle",
+    onBeforeNodeProcess: (node, context) => {
+      const ref = node["$ref"];
+      const root = context.rootNode;
+      const extUrls = root["x-ext-urls"];
+      if (typeof ref !== "string" || typeof extUrls !== "object" || extUrls === null || !isLocalRef(ref)) {
+        return;
+      }
+      const segments = ref.split("/");
+      const key = segments.at(-1) ?? "";
+      node["$ref"] = extUrls[key] ?? ref;
+    }
+  };
+};
+const cleanUp = () => {
+  return {
+    type: "lifecycle",
+    onBeforeNodeProcess: (node) => {
+      if ("properties" in node && !("type" in node)) {
+        node["type"] = "object";
+      }
+      const arrayKeywords = ["items", "prefixItems", "minItems", "maxItems", "uniqueItems"];
+      if (arrayKeywords.some((it) => Object.hasOwn(node, it)) && !("type" in node)) {
+        node["type"] = "array";
+      }
+      if ("pattern" in node && !("type" in node)) {
+        node["type"] = "string";
+      }
+    }
+  };
+};
+export {
+  cleanUp,
+  externalValueResolver,
+  loadingStatus,
+  refsEverywhere,
+  restoreOriginalRefs
+};
+//# sourceMappingURL=plugins.js.map

package/dist/plugins.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/plugins.ts"],
+  "sourcesContent": ["/**\n * This file contains a collection of plugins used for the bundler.\n * Plugins defined here can extend or modify the behavior of the bundling process,\n * such as adding lifecycle hooks or custom processing logic.\n */\nimport { isLocalRef } from '@/helpers/general'\nimport type { LifecyclePlugin } from '@scalar/json-magic/bundle'\n\n/**\n * A lifecycle plugin that adds a `$status` property to nodes during resolution.\n * - Sets `$status` to 'loading' when resolution starts.\n * - Sets `$status` to 'error' if resolution fails.\n * - Removes `$status` when resolution succeeds.\n */\nexport const loadingStatus = (): LifecyclePlugin => {\n  return {\n    type: 'lifecycle',\n    onResolveStart: (node) => {\n      node['$status'] = 'loading'\n    },\n    onResolveError: (node) => {\n      node['$status'] = 'error'\n    },\n    onResolveSuccess: (node) => {\n      delete node['$status']\n    },\n  }\n}\n\n/**\n * Lifecycle plugin to resolve and embed external content referenced by an 'externalValue' property in a node.\n *\n * When a node contains an 'externalValue' property (as a string), this plugin will:\n *   - Fetch the external resource (such as a URL or file) using the fetchUrls plugin.\n *   - If the fetch is successful, assign the fetched data to the node's 'value' property.\n *\n * This is useful for inlining external content (like examples or schemas) into the OpenAPI document during bundling.\n *\n * @param node - The node being processed, which may contain an 'externalValue' property.\n */\nexport const externalValueResolver = (): LifecyclePlugin => {\n  return {\n    type: 'lifecycle',\n    onAfterNodeProcess: async (node, context) => {\n      const externalValue = node['externalValue']\n      const cache = context.resolutionCache\n\n      // Only process if 'externalValue' is a string\n      if (typeof externalValue !== 'string') {\n        return\n      }\n\n      const loader = context.loaders.find((it) => it.validate(externalValue))\n\n      // We can not process the external value\n      if (!loader) {\n        return\n      }\n\n      if (!cache.has(externalValue)) {\n        cache.set(externalValue, loader.exec(externalValue))\n      }\n\n      const result = await cache.get(externalValue)\n\n      // If fetch is successful, assign the data to the node's 'value' property\n      if (result?.ok) {\n        node['value'] = result.data\n      }\n    },\n  }\n}\n\n/**\n * Lifecycle plugin to resolve $ref on any object, including non-standard locations like the info object.\n *\n * This plugin will:\n *   - Detect if a node contains a $ref property (as a string).\n *   - If the node is under the 'info' path, attempt to resolve the reference using fetchUrls.\n *   - Replace the node's properties with the resolved data if successful.\n *\n * Note: This currently only supports refs on the 'info' object and does not handle primitive types.\n */\nexport const refsEverywhere = (): LifecyclePlugin => {\n  return {\n    type: 'lifecycle',\n    onBeforeNodeProcess: async (node, context) => {\n      const { path, resolutionCache, parentNode } = context\n      const ref = node['$ref']\n\n      // Only process nodes that have a $ref property as a string\n      if (typeof ref !== 'string') {\n        return\n      }\n\n      // Can not resolve top level refs\n      if (!parentNode || !path.length) {\n        return\n      }\n\n      const loader = context.loaders.find((it) => it.validate(ref))\n\n      // Can not load the external ref\n      if (!loader) {\n        return\n      }\n\n      // Support resolving $ref on the info object\n      if (path[0] === 'info') {\n        // Use the cache to avoid duplicate fetches\n        if (!resolutionCache.has(ref)) {\n          resolutionCache.set(ref, loader.exec(ref))\n        }\n\n        const result = await resolutionCache.get(ref)\n\n        if (result?.ok) {\n          // Replace the ref with the resolved data\n          parentNode[path.at(-1)!] = result.data\n        }\n      }\n    },\n  }\n}\n\n/**\n * Lifecycle plugin to restore original $ref values after processing.\n *\n * This plugin is intended to be used as a \"lifecycle\" plugin in the bundling process.\n * It operates in the `onAfterNodeProcess` hook, and its main purpose is to restore\n * the original $ref values for external references that may have been replaced or\n * rewritten during the bundling process.\n *\n * How it works:\n * - For each node processed, if the node contains a $ref property (as a string),\n *   and the root document contains an \"x-ext-urls\" mapping object,\n *   the plugin will attempt to restore the original $ref value.\n * - The \"x-ext-urls\" object is expected to be a mapping from the rewritten $ref\n *   (e.g., a hashed or compressed reference) back to the original external URL or path.\n * - If a mapping exists for the current $ref, the plugin replaces the $ref value\n *   with the original value from the mapping. If no mapping exists (e.g., for local refs),\n *   the $ref value is left unchanged.\n *\n * This is useful for scenarios where you want to present or export the bundled document\n * with the original external $ref values, rather than the internal or rewritten ones.\n *\n * @returns {LifecyclePlugin} The plugin object for use in the bundler.\n */\nexport const restoreOriginalRefs = (): LifecyclePlugin => {\n  return {\n    type: 'lifecycle',\n    onBeforeNodeProcess: (node, context) => {\n      const ref = node['$ref']\n      const root = context.rootNode\n      const extUrls = root['x-ext-urls']\n\n      // Only process if $ref is a string and x-ext-urls is a valid object\n      if (typeof ref !== 'string' || typeof extUrls !== 'object' || extUrls === null || !isLocalRef(ref)) {\n        return\n      }\n\n      // Working with local refs\n\n      const segments = ref.split('/')\n      const key = segments.at(-1) ?? ''\n\n      // Replace the $ref with the original version from the mapping,\n      // or keep the current version if there is no mapping (e.g., for local refs)\n      node['$ref'] = (extUrls as Record<string, string>)[key] ?? ref\n    },\n  }\n}\n\n/**\n * Lifecycle plugin to automatically add missing \"type\" fields to OpenAPI/JSON Schema nodes.\n *\n * This plugin is intended for use as a \"lifecycle\" plugin during the bundling process.\n * It ensures that schema objects are explicitly typed, improving compatibility with OpenAPI tools and validators.\n *\n * Behavior:\n * - If a schema object has a \"properties\" field but no \"type\", it sets \"type\" to \"object\".\n *   This is required for schemas that define properties but omit the type.\n *\n * - If a schema object contains any array-related keywords (\"items\", \"prefixItems\", \"minItems\", \"maxItems\", or \"uniqueItems\")\n *   and lacks a \"type\", it sets \"type\" to \"array\". This clarifies the intent for array schemas missing an explicit type.\n *\n * - If a schema object has a \"pattern\" field but no \"type\", it sets \"type\" to \"string\".\n *   This ensures that pattern constraints are only applied to string-typed schemas.\n *\n * Usage:\n *   Add this plugin to the bundler to automatically fix schemas missing \"type: object\", \"type: array\", or \"type: string\"\n *   when defining properties, array-related keywords, or pattern constraints.\n *\n * Examples:\n *   // Before:\n *   { properties: { foo: { type: \"string\" } } }\n *   // After:\n *   { type: \"object\", properties: { foo: { type: \"string\" } } }\n *\n *   // Before:\n *   { items: { type: \"string\" } }\n *   // After:\n *   { type: \"array\", items: { type: \"string\" } }\n *\n *   // Before:\n *   { pattern: \"^[a-z]+$\" }\n *   // After:\n *   { type: \"string\", pattern: \"^[a-z]+$\" }\n */\nexport const cleanUp = (): LifecyclePlugin => {\n  return {\n    type: 'lifecycle',\n    onBeforeNodeProcess: (node) => {\n      // If the node has \"properties\" but no \"type\", set \"type\" to \"object\"\n      if ('properties' in node && !('type' in node)) {\n        node['type'] = 'object'\n      }\n\n      // Set type to 'array' for schemas that have array-related keywords but are missing a type\n      const arrayKeywords = ['items', 'prefixItems', 'minItems', 'maxItems', 'uniqueItems']\n      if (arrayKeywords.some((it) => Object.hasOwn(node, it)) && !('type' in node)) {\n        node['type'] = 'array'\n      }\n\n      // If the node has \"pattern\" but no \"type\", set \"type\" to \"string\"\n      if ('pattern' in node && !('type' in node)) {\n        node['type'] = 'string'\n      }\n    },\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/schemas/extensions/document/x-internal.d.ts

@@ -0,0 +1,4 @@
+export declare const XInternalSchema: import("@sinclair/typebox").TObject<{
+    'x-internal': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+//# sourceMappingURL=x-internal.d.ts.map

package/dist/schemas/extensions/document/x-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-internal.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-internal.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;EAE1B,CAAA"}

package/dist/schemas/extensions/document/x-internal.js

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+const XInternalSchema = Type.Object({
+  "x-internal": Type.Optional(Type.Boolean())
+});
+export {
+  XInternalSchema
+};
+//# sourceMappingURL=x-internal.js.map

package/dist/schemas/extensions/document/x-internal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/document/x-internal.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\nexport const XInternalSchema = Type.Object({\n  'x-internal': Type.Optional(Type.Boolean()),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,kBAAkB,KAAK,OAAO;AAAA,EACzC,cAAc,KAAK,SAAS,KAAK,QAAQ,CAAC;AAC5C,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/document/x-scalar-icon.d.ts

@@ -0,0 +1,4 @@
+export declare const XScalarIconSchema: import("@sinclair/typebox").TObject<{
+    'x-scalar-icon': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+//# sourceMappingURL=x-scalar-icon.d.ts.map

package/dist/schemas/extensions/document/x-scalar-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-icon.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-icon.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;EAE5B,CAAA"}

package/dist/schemas/extensions/document/x-scalar-icon.js

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+const XScalarIconSchema = Type.Object({
+  "x-scalar-icon": Type.Optional(Type.String())
+});
+export {
+  XScalarIconSchema
+};
+//# sourceMappingURL=x-scalar-icon.js.map

package/dist/schemas/extensions/document/x-scalar-icon.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/document/x-scalar-icon.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\nexport const XScalarIconSchema = Type.Object({\n  'x-scalar-icon': Type.Optional(Type.String()),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,oBAAoB,KAAK,OAAO;AAAA,EAC3C,iBAAiB,KAAK,SAAS,KAAK,OAAO,CAAC;AAC9C,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/document/x-scalar-ignore.d.ts

@@ -0,0 +1,4 @@
+export declare const XScalarIgnoreSchema: import("@sinclair/typebox").TObject<{
+    'x-scalar-ignore': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+//# sourceMappingURL=x-scalar-ignore.d.ts.map

package/dist/schemas/extensions/document/x-scalar-ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-ignore.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-ignore.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;EAE9B,CAAA"}

package/dist/schemas/extensions/document/x-scalar-ignore.js

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+const XScalarIgnoreSchema = Type.Object({
+  "x-scalar-ignore": Type.Optional(Type.Boolean())
+});
+export {
+  XScalarIgnoreSchema
+};
+//# sourceMappingURL=x-scalar-ignore.js.map

package/dist/schemas/extensions/document/x-scalar-ignore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/document/x-scalar-ignore.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\nexport const XScalarIgnoreSchema = Type.Object({\n  'x-scalar-ignore': Type.Optional(Type.Boolean()),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,sBAAsB,KAAK,OAAO;AAAA,EAC7C,mBAAmB,KAAK,SAAS,KAAK,QAAQ,CAAC;AACjD,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/document/x-scalar-sdk-installation.d.ts

@@ -0,0 +1,8 @@
+export declare const XScalarSdkInstallationSchema: import("@sinclair/typebox").TObject<{
+    'x-scalar-sdk-installation': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        lang: import("@sinclair/typebox").TString;
+        source: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>>;
+}>;
+//# sourceMappingURL=x-scalar-sdk-installation.d.ts.map

package/dist/schemas/extensions/document/x-scalar-sdk-installation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-sdk-installation.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-sdk-installation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B;;;;;;EAUvC,CAAA"}

package/dist/schemas/extensions/document/x-scalar-sdk-installation.js

@@ -0,0 +1,16 @@
+import { Type } from "@sinclair/typebox";
+const XScalarSdkInstallationSchema = Type.Object({
+  "x-scalar-sdk-installation": Type.Optional(
+    Type.Array(
+      Type.Object({
+        lang: Type.String(),
+        source: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String())
+      })
+    )
+  )
+});
+export {
+  XScalarSdkInstallationSchema
+};
+//# sourceMappingURL=x-scalar-sdk-installation.js.map

package/dist/schemas/extensions/document/x-scalar-sdk-installation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/document/x-scalar-sdk-installation.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\nexport const XScalarSdkInstallationSchema = Type.Object({\n  'x-scalar-sdk-installation': Type.Optional(\n    Type.Array(\n      Type.Object({\n        lang: Type.String(),\n        source: Type.Optional(Type.String()),\n        description: Type.Optional(Type.String()),\n      }),\n    ),\n  ),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,+BAA+B,KAAK,OAAO;AAAA,EACtD,6BAA6B,KAAK;AAAA,IAChC,KAAK;AAAA,MACH,KAAK,OAAO;AAAA,QACV,MAAM,KAAK,OAAO;AAAA,QAClB,QAAQ,KAAK,SAAS,KAAK,OAAO,CAAC;AAAA,QACnC,aAAa,KAAK,SAAS,KAAK,OAAO,CAAC;AAAA,MAC1C,CAAC;AAAA,IACH;AAAA,EACF;AACF,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/operation/x-badge.d.ts

@@ -0,0 +1,58 @@
+import { type Static } from '@sinclair/typebox';
+/**
+ * Schema for individual badge configuration in x-badges extension.
+ * Badges are indicators that can be displayed in API documentation.
+ */
+export declare const BadgeSchema: import("@sinclair/typebox").TObject<{
+    /** The text that displays in the badge. This is required for all badges. */
+    name: import("@sinclair/typebox").TString;
+    /**
+     * The position of the badge in relation to the header.
+     * Defaults to 'after' if not specified.
+     */
+    position: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"before">, import("@sinclair/typebox").TLiteral<"after">]>>;
+    /**
+     * The color of the badge. Can be defined in various formats such as color keywords,
+     * RGB, RGBA, HSL, HSLA, and Hexadecimal.
+     */
+    color: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type XBadge = Static<typeof BadgeSchema>;
+/**
+ * You can add badges to operations to use as indicators in documentation. Each operation can have multiple badges, and the displayed color is also configurable. The following example sets badges on the GET `/hello-world` operation:
+ *
+ * ```yaml
+ * openapi: 3.1.0
+ * info:
+ *   title: x-badges
+ *   version: 1.0.0
+ * paths:
+ *   /hello-world:
+ *     get:
+ *       summary: Hello World
+ *       x-badges:
+ *         - name: 'Alpha'
+ *         - name: 'Beta'
+ *           position: before
+ *         - name: 'Gamma'
+ *           position: after
+ *           color: '#ffcc00'
+```
+ */
+export declare const XBadgesSchema: import("@sinclair/typebox").TObject<{
+    'x-badges': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        /** The text that displays in the badge. This is required for all badges. */
+        name: import("@sinclair/typebox").TString;
+        /**
+         * The position of the badge in relation to the header.
+         * Defaults to 'after' if not specified.
+         */
+        position: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"before">, import("@sinclair/typebox").TLiteral<"after">]>>;
+        /**
+         * The color of the badge. Can be defined in various formats such as color keywords,
+         * RGB, RGBA, HSL, HSLA, and Hexadecimal.
+         */
+        color: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>>;
+}>;
+//# sourceMappingURL=x-badge.d.ts.map

package/dist/schemas/extensions/operation/x-badge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-badge.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-badge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,WAAW;IAEpB,4EAA4E;;IAK5E;;;OAGG;;IAOH;;;OAGG;;EAYN,CAAA;AAED,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa;;QAvDtB,4EAA4E;;QAK5E;;;WAGG;;QAOH;;;WAGG;;;EAuCL,CAAA"}

package/dist/schemas/extensions/operation/x-badge.js

@@ -0,0 +1,41 @@
+import { Type } from "@sinclair/typebox";
+const BadgeSchema = Type.Object(
+  {
+    /** The text that displays in the badge. This is required for all badges. */
+    name: Type.String({
+      description: "The text that displays in the badge",
+      minLength: 1
+    }),
+    /**
+     * The position of the badge in relation to the header.
+     * Defaults to 'after' if not specified.
+     */
+    position: Type.Optional(
+      Type.Union([Type.Literal("before"), Type.Literal("after")], {
+        description: "The position of the badge in relation to the header",
+        default: "after"
+      })
+    ),
+    /**
+     * The color of the badge. Can be defined in various formats such as color keywords,
+     * RGB, RGBA, HSL, HSLA, and Hexadecimal.
+     */
+    color: Type.Optional(
+      Type.String({
+        description: "The color of the badge in various formats (keywords, RGB, RGBA, HSL, HSLA, Hexadecimal)",
+        pattern: "^(#([0-9A-Fa-f]{3}){1,2}|rgb\\(\\s*\\d+\\s*,\\s*\\d+\\s*,\\s*\\d+\\s*\\)|rgba\\(\\s*\\d+\\s*,\\s*\\d+\\s*,\\s*\\d+\\s*,\\s*[0-9.]*\\s*\\)|hsl\\(\\s*\\d+\\s*,\\s*\\d+%\\s*,\\s*\\d+%\\s*\\)|hsla\\(\\s*\\d+\\s*,\\s*\\d+%\\s*,\\s*\\d+%\\s*,\\s*[0-9.]*\\s*\\)|[a-zA-Z]+)$"
+      })
+    )
+  },
+  {
+    description: "Configuration for a single badge in the x-badges extension"
+  }
+);
+const XBadgesSchema = Type.Object({
+  "x-badges": Type.Optional(Type.Array(BadgeSchema))
+});
+export {
+  BadgeSchema,
+  XBadgesSchema
+};
+//# sourceMappingURL=x-badge.js.map

package/dist/schemas/extensions/operation/x-badge.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/operation/x-badge.ts"],
+  "sourcesContent": ["import { Type, type Static } from '@sinclair/typebox'\n\n/**\n * Schema for individual badge configuration in x-badges extension.\n * Badges are indicators that can be displayed in API documentation.\n */\nexport const BadgeSchema = Type.Object(\n  {\n    /** The text that displays in the badge. This is required for all badges. */\n    name: Type.String({\n      description: 'The text that displays in the badge',\n      minLength: 1,\n    }),\n    /**\n     * The position of the badge in relation to the header.\n     * Defaults to 'after' if not specified.\n     */\n    position: Type.Optional(\n      Type.Union([Type.Literal('before'), Type.Literal('after')], {\n        description: 'The position of the badge in relation to the header',\n        default: 'after',\n      }),\n    ),\n    /**\n     * The color of the badge. Can be defined in various formats such as color keywords,\n     * RGB, RGBA, HSL, HSLA, and Hexadecimal.\n     */\n    color: Type.Optional(\n      Type.String({\n        description: 'The color of the badge in various formats (keywords, RGB, RGBA, HSL, HSLA, Hexadecimal)',\n        pattern:\n          '^(#([0-9A-Fa-f]{3}){1,2}|rgb\\\\(\\\\s*\\\\d+\\\\s*,\\\\s*\\\\d+\\\\s*,\\\\s*\\\\d+\\\\s*\\\\)|rgba\\\\(\\\\s*\\\\d+\\\\s*,\\\\s*\\\\d+\\\\s*,\\\\s*\\\\d+\\\\s*,\\\\s*[0-9.]*\\\\s*\\\\)|hsl\\\\(\\\\s*\\\\d+\\\\s*,\\\\s*\\\\d+%\\\\s*,\\\\s*\\\\d+%\\\\s*\\\\)|hsla\\\\(\\\\s*\\\\d+\\\\s*,\\\\s*\\\\d+%\\\\s*,\\\\s*\\\\d+%\\\\s*,\\\\s*[0-9.]*\\\\s*\\\\)|[a-zA-Z]+)$',\n      }),\n    ),\n  },\n  {\n    description: 'Configuration for a single badge in the x-badges extension',\n  },\n)\n\nexport type XBadge = Static<typeof BadgeSchema>\n\n/**\n * You can add badges to operations to use as indicators in documentation. Each operation can have multiple badges, and the displayed color is also configurable. The following example sets badges on the GET `/hello-world` operation:\n *\n * ```yaml\n * openapi: 3.1.0\n * info:\n *   title: x-badges\n *   version: 1.0.0\n * paths:\n *   /hello-world:\n *     get:\n *       summary: Hello World\n *       x-badges:\n *         - name: 'Alpha'\n *         - name: 'Beta'\n *           position: before\n *         - name: 'Gamma'\n *           position: after\n *           color: '#ffcc00'\n```\n */\nexport const XBadgesSchema = Type.Object({\n  'x-badges': Type.Optional(Type.Array(BadgeSchema)),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAyB;AAM3B,MAAM,cAAc,KAAK;AAAA,EAC9B;AAAA;AAAA,IAEE,MAAM,KAAK,OAAO;AAAA,MAChB,aAAa;AAAA,MACb,WAAW;AAAA,IACb,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,IAKD,UAAU,KAAK;AAAA,MACb,KAAK,MAAM,CAAC,KAAK,QAAQ,QAAQ,GAAG,KAAK,QAAQ,OAAO,CAAC,GAAG;AAAA,QAC1D,aAAa;AAAA,QACb,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA;AAAA;AAAA;AAAA;AAAA,IAKA,OAAO,KAAK;AAAA,MACV,KAAK,OAAO;AAAA,QACV,aAAa;AAAA,QACb,SACE;AAAA,MACJ,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EACA;AAAA,IACE,aAAa;AAAA,EACf;AACF;AAyBO,MAAM,gBAAgB,KAAK,OAAO;AAAA,EACvC,YAAY,KAAK,SAAS,KAAK,MAAM,WAAW,CAAC;AACnD,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/operation/x-code-samples.d.ts

@@ -0,0 +1,23 @@
+export declare const XCodeSampleSchema: import("@sinclair/typebox").TObject<{
+    lang: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    source: import("@sinclair/typebox").TString;
+}>;
+export declare const XCodeSamplesSchema: import("@sinclair/typebox").TObject<{
+    'x-codeSamples': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        lang: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        source: import("@sinclair/typebox").TString;
+    }>>>;
+    'x-code-samples': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        lang: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        source: import("@sinclair/typebox").TString;
+    }>>>;
+    'x-custom-examples': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        lang: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        source: import("@sinclair/typebox").TString;
+    }>>>;
+}>;
+//# sourceMappingURL=x-code-samples.d.ts.map

package/dist/schemas/extensions/operation/x-code-samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-code-samples.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-code-samples.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;EAI7B,CAAA"}

package/dist/schemas/extensions/operation/x-code-samples.js

@@ -0,0 +1,16 @@
+import { Type } from "@sinclair/typebox";
+const XCodeSampleSchema = Type.Object({
+  lang: Type.Optional(Type.String()),
+  label: Type.Optional(Type.String()),
+  source: Type.String()
+});
+const XCodeSamplesSchema = Type.Object({
+  "x-codeSamples": Type.Optional(Type.Array(XCodeSampleSchema)),
+  "x-code-samples": Type.Optional(Type.Array(XCodeSampleSchema)),
+  "x-custom-examples": Type.Optional(Type.Array(XCodeSampleSchema))
+});
+export {
+  XCodeSampleSchema,
+  XCodeSamplesSchema
+};
+//# sourceMappingURL=x-code-samples.js.map

package/dist/schemas/extensions/operation/x-code-samples.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/operation/x-code-samples.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\nexport const XCodeSampleSchema = Type.Object({\n  lang: Type.Optional(Type.String()),\n  label: Type.Optional(Type.String()),\n  source: Type.String(),\n})\n\nexport const XCodeSamplesSchema = Type.Object({\n  'x-codeSamples': Type.Optional(Type.Array(XCodeSampleSchema)),\n  'x-code-samples': Type.Optional(Type.Array(XCodeSampleSchema)),\n  'x-custom-examples': Type.Optional(Type.Array(XCodeSampleSchema)),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,oBAAoB,KAAK,OAAO;AAAA,EAC3C,MAAM,KAAK,SAAS,KAAK,OAAO,CAAC;AAAA,EACjC,OAAO,KAAK,SAAS,KAAK,OAAO,CAAC;AAAA,EAClC,QAAQ,KAAK,OAAO;AACtB,CAAC;AAEM,MAAM,qBAAqB,KAAK,OAAO;AAAA,EAC5C,iBAAiB,KAAK,SAAS,KAAK,MAAM,iBAAiB,CAAC;AAAA,EAC5D,kBAAkB,KAAK,SAAS,KAAK,MAAM,iBAAiB,CAAC;AAAA,EAC7D,qBAAqB,KAAK,SAAS,KAAK,MAAM,iBAAiB,CAAC;AAClE,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/operation/x-post-response.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Post response scripts allow to execute arbitrary code after a response is received
+ *
+ * This is useful for:
+ * - Extracting data from the response, or
+ * - Testing the response
+ *
+ * @example
+ * ```yaml
+ * x-post-response: |
+ *   pm.test("Status code is 200", () => {
+ *     pm.response.to.have.status(200)
+ *   })
+ * ```
+ */
+export declare const XPostResponseSchema: import("@sinclair/typebox").TObject<{
+    'x-post-response': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+//# sourceMappingURL=x-post-response.d.ts.map

package/dist/schemas/extensions/operation/x-post-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-post-response.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-post-response.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB;;EAE9B,CAAA"}

package/dist/schemas/extensions/operation/x-post-response.js

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+const XPostResponseSchema = Type.Object({
+  "x-post-response": Type.Optional(Type.String())
+});
+export {
+  XPostResponseSchema
+};
+//# sourceMappingURL=x-post-response.js.map

package/dist/schemas/extensions/operation/x-post-response.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/operation/x-post-response.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\n/**\n * Post response scripts allow to execute arbitrary code after a response is received\n *\n * This is useful for:\n * - Extracting data from the response, or\n * - Testing the response\n *\n * @example\n * ```yaml\n * x-post-response: |\n *   pm.test(\"Status code is 200\", () => {\n *     pm.response.to.have.status(200)\n *   })\n * ```\n */\nexport const XPostResponseSchema = Type.Object({\n  'x-post-response': Type.Optional(Type.String()),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAiBd,MAAM,sBAAsB,KAAK,OAAO;AAAA,EAC7C,mBAAmB,KAAK,SAAS,KAAK,OAAO,CAAC;AAChD,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/operation/x-scalar-stability.d.ts

@@ -0,0 +1,18 @@
+export declare const XScalarStabilityValues: {
+    readonly Deprecated: "deprecated";
+    readonly Experimental: "experimental";
+    readonly Stable: "stable";
+};
+export type XScalarStabilityValues = (typeof XScalarStabilityValues)[keyof typeof XScalarStabilityValues];
+/**
+ * An OpenAPI extension to indicate the stability of the operation
+ *
+ * @example
+ * ```yaml
+ * x-scalar-stability: deprecated
+ * ```
+ */
+export declare const XScalarStabilitySchema: import("@sinclair/typebox").TObject<{
+    'x-scalar-stability': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"deprecated">, import("@sinclair/typebox").TLiteral<"experimental">, import("@sinclair/typebox").TLiteral<"stable">]>>;
+}>;
+//# sourceMappingURL=x-scalar-stability.d.ts.map

package/dist/schemas/extensions/operation/x-scalar-stability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-stability.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-scalar-stability.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAA;AAEV,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,OAAO,sBAAsB,CAAC,CAAA;AAEzG;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;EAIjC,CAAA"}

package/dist/schemas/extensions/operation/x-scalar-stability.js

@@ -0,0 +1,16 @@
+import { Type } from "@sinclair/typebox";
+const XScalarStabilityValues = {
+  Deprecated: "deprecated",
+  Experimental: "experimental",
+  Stable: "stable"
+};
+const XScalarStabilitySchema = Type.Object({
+  "x-scalar-stability": Type.Optional(
+    Type.Union([Type.Literal("deprecated"), Type.Literal("experimental"), Type.Literal("stable")])
+  )
+});
+export {
+  XScalarStabilitySchema,
+  XScalarStabilityValues
+};
+//# sourceMappingURL=x-scalar-stability.js.map

package/dist/schemas/extensions/operation/x-scalar-stability.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/operation/x-scalar-stability.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\nexport const XScalarStabilityValues = {\n  Deprecated: 'deprecated',\n  Experimental: 'experimental',\n  Stable: 'stable',\n} as const\n\nexport type XScalarStabilityValues = (typeof XScalarStabilityValues)[keyof typeof XScalarStabilityValues]\n\n/**\n * An OpenAPI extension to indicate the stability of the operation\n *\n * @example\n * ```yaml\n * x-scalar-stability: deprecated\n * ```\n */\nexport const XScalarStabilitySchema = Type.Object({\n  'x-scalar-stability': Type.Optional(\n    Type.Union([Type.Literal('deprecated'), Type.Literal('experimental'), Type.Literal('stable')]),\n  ),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,yBAAyB;AAAA,EACpC,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,QAAQ;AACV;AAYO,MAAM,yBAAyB,KAAK,OAAO;AAAA,EAChD,sBAAsB,KAAK;AAAA,IACzB,KAAK,MAAM,CAAC,KAAK,QAAQ,YAAY,GAAG,KAAK,QAAQ,cAAc,GAAG,KAAK,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC/F;AACF,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/schema/x-additional-properties-name.d.ts

@@ -0,0 +1,11 @@
+/**
+ * x-additionalPropertiesName
+ *
+ * Custom attribute name for additionalProperties in a schema.
+ * This allows specifying a descriptive name for additional properties
+ * that may be present in an object.
+ */
+export declare const XAdditionalPropertiesNameSchema: import("@sinclair/typebox").TObject<{
+    'x-additionalPropertiesName': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+//# sourceMappingURL=x-additional-properties-name.d.ts.map

package/dist/schemas/extensions/schema/x-additional-properties-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-additional-properties-name.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-additional-properties-name.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;EAE1C,CAAA"}

package/dist/schemas/extensions/schema/x-additional-properties-name.js

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+const XAdditionalPropertiesNameSchema = Type.Object({
+  "x-additionalPropertiesName": Type.Optional(Type.String())
+});
+export {
+  XAdditionalPropertiesNameSchema
+};
+//# sourceMappingURL=x-additional-properties-name.js.map

package/dist/schemas/extensions/schema/x-additional-properties-name.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/schema/x-additional-properties-name.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\n/**\n * x-additionalPropertiesName\n *\n * Custom attribute name for additionalProperties in a schema.\n * This allows specifying a descriptive name for additional properties\n * that may be present in an object.\n */\nexport const XAdditionalPropertiesNameSchema = Type.Object({\n  'x-additionalPropertiesName': Type.Optional(Type.String()),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AASd,MAAM,kCAAkC,KAAK,OAAO;AAAA,EACzD,8BAA8B,KAAK,SAAS,KAAK,OAAO,CAAC;AAC3D,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/schema/x-enum-descriptions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * x-enumDescriptions
+ *
+ * Maps enum values to their descriptions. Each key should correspond to
+ * an enum value, and the value is the description for that enum value.
+ *
+ * Example:
+ * x-enumDescriptions:
+ *   missing_features: "Missing features"
+ *   too_expensive: "Too expensive"
+ *   unused: "Unused"
+ *   other: "Other"
+ */
+export declare const XEnumDescriptionsSchema: import("@sinclair/typebox").TObject<{
+    'x-enumDescriptions': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+}>;
+//# sourceMappingURL=x-enum-descriptions.d.ts.map

package/dist/schemas/extensions/schema/x-enum-descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-enum-descriptions.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-enum-descriptions.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB;;EAElC,CAAA"}

package/dist/schemas/extensions/schema/x-enum-descriptions.js

@@ -0,0 +1,8 @@
+import { Type } from "@sinclair/typebox";
+const XEnumDescriptionsSchema = Type.Object({
+  "x-enumDescriptions": Type.Optional(Type.Record(Type.String(), Type.String(), { default: {} }))
+});
+export {
+  XEnumDescriptionsSchema
+};
+//# sourceMappingURL=x-enum-descriptions.js.map

package/dist/schemas/extensions/schema/x-enum-descriptions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/schema/x-enum-descriptions.ts"],
+  "sourcesContent": ["import { Type } from '@sinclair/typebox'\n\n/**\n * x-enumDescriptions\n *\n * Maps enum values to their descriptions. Each key should correspond to\n * an enum value, and the value is the description for that enum value.\n *\n * Example:\n * x-enumDescriptions:\n *   missing_features: \"Missing features\"\n *   too_expensive: \"Too expensive\"\n *   unused: \"Unused\"\n *   other: \"Other\"\n */\nexport const XEnumDescriptionsSchema = Type.Object({\n  'x-enumDescriptions': Type.Optional(Type.Record(Type.String(), Type.String(), { default: {} })),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAed,MAAM,0BAA0B,KAAK,OAAO;AAAA,EACjD,sBAAsB,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,OAAO,GAAG,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;AAChG,CAAC;",
+  "names": []
+}

package/dist/schemas/extensions/schema/x-variable.d.ts

@@ -0,0 +1,4 @@
+export declare const XVariableSchema: import("@sinclair/typebox").TObject<{
+    'x-variable': import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+//# sourceMappingURL=x-variable.d.ts.map

package/dist/schemas/extensions/schema/x-variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-variable.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-variable.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;EAE1B,CAAA"}