@scalar/workspace-store 0.16.0 → 0.17.0

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/document/x-scalar-icon.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\nexport const XScalarIconSchema = Type.Object({\n  'x-scalar-icon': Type.Optional(Type.String()),\n})\n"],
+  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\nexport const XScalarIconSchema = Type.Object({\n  'x-scalar-icon': Type.Optional(Type.String()),\n})\n\nexport type XScalarIcon = {\n  /** A custom icon representing the collection */\n  'x-scalar-icon'?: 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

@@ -1,4 +1,8 @@
 export declare const XScalarIgnoreSchema: import("@scalar/typebox").TObject<{
     'x-scalar-ignore': import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
 }>;
+export type XScalarIgnore = {
+    /** Interal extension to mark an entity as ignored */
+    'x-scalar-ignore'?: boolean;
+};
 //# sourceMappingURL=x-scalar-ignore.d.ts.map

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

@@ -1 +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"}
+{"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;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/document/x-scalar-ignore.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\nexport const XScalarIgnoreSchema = Type.Object({\n  'x-scalar-ignore': Type.Optional(Type.Boolean()),\n})\n"],
+  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\nexport const XScalarIgnoreSchema = Type.Object({\n  'x-scalar-ignore': Type.Optional(Type.Boolean()),\n})\n\nexport type XScalarIgnore = {\n  /** Interal extension to mark an entity as ignored */\n  'x-scalar-ignore'?: 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

@@ -1,4 +1,3 @@
-import type { Static } from '@scalar/typebox';
 export declare const XScalarSdkInstallationSchema: import("@scalar/typebox").TObject<{
     'x-scalar-sdk-installation': import("@scalar/typebox").TOptional<import("@scalar/typebox").TArray<import("@scalar/typebox").TObject<{
         lang: import("@scalar/typebox").TString;
@@ -6,5 +5,12 @@ export declare const XScalarSdkInstallationSchema: import("@scalar/typebox").TOb
         description: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
     }>>>;
 }>;
-export type XScalarSdkInstallation = Static<typeof XScalarSdkInstallationSchema>;
+export type XScalarSdkInstallation = {
+    /** Scalar SDK installation information. */
+    'x-scalar-sdk-installation'?: {
+        lang: string;
+        source?: string;
+        description?: string;
+    }[];
+};
 //# sourceMappingURL=x-scalar-sdk-installation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-sdk-installation.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-sdk-installation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAG7C,eAAO,MAAM,4BAA4B;;;;;;EAUvC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAA"}
+{"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;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,2CAA2C;IAC3C,2BAA2B,CAAC,EAAE;QAC5B,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,EAAE,CAAA;CACJ,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/document/x-scalar-sdk-installation.ts"],
-  "sourcesContent": ["import type { Static } from '@scalar/typebox'\nimport { Type } from '@scalar/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\nexport type XScalarSdkInstallation = Static<typeof XScalarSdkInstallationSchema>\n"],
-  "mappings": "AACA,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;",
+  "sourcesContent": ["import { Type } from '@scalar/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\nexport type XScalarSdkInstallation = {\n  /** Scalar SDK installation information. */\n  'x-scalar-sdk-installation'?: {\n    lang: string\n    source?: string\n    description?: string\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/document/x-tags.d.ts

@@ -1,4 +1,7 @@
 export declare const XTags: import("@scalar/typebox").TObject<{
     'x-tags': import("@scalar/typebox").TOptional<import("@scalar/typebox").TArray<import("@scalar/typebox").TString>>;
 }>;
+export type XTags = {
+    'x-tags'?: string[];
+};
 //# sourceMappingURL=x-tags.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-tags.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-tags.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;EAEhB,CAAA"}
+{"version":3,"file":"x-tags.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-tags.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;EAEhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/document/x-tags.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\nexport const XTags = Type.Object({\n  'x-tags': Type.Optional(Type.Array(Type.String())),\n})\n"],
+  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\nexport const XTags = Type.Object({\n  'x-tags': Type.Optional(Type.Array(Type.String())),\n})\n\nexport type XTags = {\n  'x-tags'?: string[]\n}\n"],
   "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,QAAQ,KAAK,OAAO;AAAA,EAC/B,UAAU,KAAK,SAAS,KAAK,MAAM,KAAK,OAAO,CAAC,CAAC;AACnD,CAAC;",
   "names": []
 }

package/dist/schemas/extensions/example/x-disabled.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenAPI extension to control whether a parameter example is enabled (checkbox on) or disabled (checkbox off).
+ *
+ * This extension is typically used in API tools to determine if a parameter (such as a header, query, or cookie)
+ * should be included in the request when sending an example. If `x-disabled: true`, the parameter example is considered
+ * "off" (checkbox unchecked) and will not be sent with the request. If `x-disabled: false` or omitted, the parameter
+ * example is "on" (checkbox checked) and will be sent.
+ *
+ * @example
+ * ```yaml
+ * x-disabled: true   # Do not send this parameter example in the request
+ * x-disabled: false  # Send this parameter example in the request
+ * ```
+ */
+export declare const XDisabled: import("@scalar/typebox").TObject<{
+    'x-disabled': import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+}>;
+//# sourceMappingURL=x-disabled.d.ts.map

package/dist/schemas/extensions/example/x-disabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-disabled.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/example/x-disabled.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS;;EAEpB,CAAA"}

package/dist/schemas/extensions/example/x-disabled.js

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

package/dist/schemas/extensions/example/x-disabled.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/example/x-disabled.ts"],
+  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\n/**\n * OpenAPI extension to control whether a parameter example is enabled (checkbox on) or disabled (checkbox off).\n *\n * This extension is typically used in API tools to determine if a parameter (such as a header, query, or cookie)\n * should be included in the request when sending an example. If `x-disabled: true`, the parameter example is considered\n * \"off\" (checkbox unchecked) and will not be sent with the request. If `x-disabled: false` or omitted, the parameter\n * example is \"on\" (checkbox checked) and will be sent.\n *\n * @example\n * ```yaml\n * x-disabled: true   # Do not send this parameter example in the request\n * x-disabled: false  # Send this parameter example in the request\n * ```\n */\nexport const XDisabled = Type.Object({\n  'x-disabled': Type.Optional(Type.Boolean()),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAgBd,MAAM,YAAY,KAAK,OAAO;AAAA,EACnC,cAAc,KAAK,SAAS,KAAK,QAAQ,CAAC;AAC5C,CAAC;",
+  "names": []
+}

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

@@ -1,9 +1,8 @@
-import { type Static } from '@scalar/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("@scalar/typebox").TObject<{
+export declare const XBadgeSchema: import("@scalar/typebox").TObject<{
     /** The text that displays in the badge. This is required for all badges. */
     name: import("@scalar/typebox").TString;
     /**
@@ -17,29 +16,46 @@ export declare const BadgeSchema: import("@scalar/typebox").TObject<{
      */
     color: import("@scalar/typebox").TOptional<import("@scalar/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'
-```
+ * Schema for individual badge configuration in x-badges extension.
+ * Badges are indicators that can be displayed in API documentation.
  */
+export type XBadge = {
+    /** The text that displays in the badge. This is required for all badges. */
+    name: string;
+    /**
+     * The position of the badge in relation to the header.
+     * @default 'after'
+     */
+    position?: 'before' | 'after';
+    /**
+     * The color of the badge. Can be defined in various formats such as color keywords,
+     * RGB, RGBA, HSL, HSLA, and Hexadecimal.
+     */
+    color?: string;
+};
 export declare const XBadgesSchema: import("@scalar/typebox").TObject<{
+    /**
+     * 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'
+    ```
+     */
     'x-badges': import("@scalar/typebox").TOptional<import("@scalar/typebox").TArray<import("@scalar/typebox").TObject<{
         /** The text that displays in the badge. This is required for all badges. */
         name: import("@scalar/typebox").TString;
@@ -55,4 +71,28 @@ export declare const XBadgesSchema: import("@scalar/typebox").TObject<{
         color: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
     }>>>;
 }>;
+export type XBadges = {
+    /**
+     * 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'
+    ```
+     */
+    'x-badges'?: XBadge[];
+};
 //# sourceMappingURL=x-badge.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-badge.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-badge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,iBAAiB,CAAA;AAEnD;;;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"}
+{"version":3,"file":"x-badge.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-badge.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,YAAY;IAErB,4EAA4E;;IAK5E;;;OAGG;;IAOH;;;OAGG;;EAYN,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,aAAa;IACxB;;;;;;;;;;;;;;;;;;;;OAoBG;;QAxED,4EAA4E;;QAK5E;;;WAGG;;QAOH;;;WAGG;;;EAwDL,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA"}

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

@@ -1,5 +1,5 @@
 import { Type } from "@scalar/typebox";
-const BadgeSchema = Type.Object(
+const XBadgeSchema = Type.Object(
   {
     /** The text that displays in the badge. This is required for all badges. */
     name: Type.String({
@@ -32,10 +32,31 @@ const BadgeSchema = Type.Object(
   }
 );
 const XBadgesSchema = Type.Object({
-  "x-badges": Type.Optional(Type.Array(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'
+  ```
+   */
+  "x-badges": Type.Optional(Type.Array(XBadgeSchema))
 });
 export {
-  BadgeSchema,
+  XBadgeSchema,
   XBadgesSchema
 };
 //# sourceMappingURL=x-badge.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/operation/x-badge.ts"],
-  "sourcesContent": ["import { type Static, Type } from '@scalar/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,SAAsB,YAAY;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;",
+  "sourcesContent": ["import { Type } from '@scalar/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 XBadgeSchema = 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\n/**\n * Schema for individual badge configuration in x-badges extension.\n * Badges are indicators that can be displayed in API documentation.\n */\nexport type XBadge = {\n  /** The text that displays in the badge. This is required for all badges. */\n  name: string\n  /**\n   * The position of the badge in relation to the header.\n   * @default 'after'\n   */\n  position?: 'before' | 'after'\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?: string\n}\n\nexport const XBadgesSchema = Type.Object({\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   */\n  'x-badges': Type.Optional(Type.Array(XBadgeSchema)),\n})\n\nexport type XBadges = {\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   */\n  'x-badges'?: XBadge[]\n}\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAMd,MAAM,eAAe,KAAK;AAAA,EAC/B;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;AAqBO,MAAM,gBAAgB,KAAK,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBvC,YAAY,KAAK,SAAS,KAAK,MAAM,YAAY,CAAC;AACpD,CAAC;",
   "names": []
 }

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

@@ -1,4 +1,3 @@
-import { type Static } from '@scalar/typebox';
 export declare const XCodeSampleSchema: import("@scalar/typebox").TObject<{
     lang: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
     label: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
@@ -21,5 +20,14 @@ export declare const XCodeSamplesSchema: import("@scalar/typebox").TObject<{
         source: import("@scalar/typebox").TString;
     }>>>;
 }>;
-export type XCodeSample = Static<typeof XCodeSampleSchema>;
+export type XCodeSample = {
+    lang?: string;
+    label?: string;
+    source: string;
+};
+export type XCodeSamples = {
+    'x-codeSamples'?: XCodeSample[];
+    'x-code-samples'?: XCodeSample[];
+    'x-custom-examples'?: XCodeSample[];
+};
 //# sourceMappingURL=x-code-samples.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-code-samples.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-code-samples.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,iBAAiB,CAAA;AAEnD,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;EAI7B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"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;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,eAAe,CAAC,EAAE,WAAW,EAAE,CAAA;IAC/B,gBAAgB,CAAC,EAAE,WAAW,EAAE,CAAA;IAChC,mBAAmB,CAAC,EAAE,WAAW,EAAE,CAAA;CACpC,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/operation/x-code-samples.ts"],
-  "sourcesContent": ["import { type Static, Type } from '@scalar/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\nexport type XCodeSample = Static<typeof XCodeSampleSchema>\n"],
-  "mappings": "AAAA,SAAsB,YAAY;AAE3B,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;",
+  "sourcesContent": ["import { Type } from '@scalar/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\nexport type XCodeSample = {\n  lang?: string\n  label?: string\n  source: string\n}\n\nexport type XCodeSamples = {\n  'x-codeSamples'?: XCodeSample[]\n  'x-code-samples'?: XCodeSample[]\n  'x-custom-examples'?: XCodeSample[]\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

@@ -16,4 +16,22 @@
 export declare const XPostResponseSchema: import("@scalar/typebox").TObject<{
     'x-post-response': import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
 }>;
+export type XPostResponse = {
+    /**
+     * 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)
+     *   })
+     * ```
+     */
+    'x-post-response'?: string;
+};
 //# sourceMappingURL=x-post-response.d.ts.map

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

@@ -1 +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"}
+{"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;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/operation/x-post-response.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/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"],
+  "sourcesContent": ["import { Type } from '@scalar/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\nexport type XPostResponse = {\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   */\n  'x-post-response'?: 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

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

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

@@ -1 +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"}
+{"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;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,sBAAsB,CAAA;CAC9C,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/operation/x-scalar-stability.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/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"],
+  "sourcesContent": ["import { Type } from '@scalar/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\nexport type XScalarStability = {\n  /**\n   * An OpenAPI extension to indicate the stability of the operation\n   *\n   * @example\n   * ```yaml\n   * x-scalar-stability: deprecated\n   * ```\n   */\n  'x-scalar-stability'?: XScalarStabilityValues\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/parameter/x-global.d.ts

@@ -0,0 +1,13 @@
+/**
+ * OpenAPI extension used by the api-client application to determine if a parameter is considered global in scope
+ * for the entire workspace. When set, this parameter will be injected into every request automatically.
+ *
+ * @example
+ * ```yaml
+ * x-global: true
+ * ```
+ */
+export declare const XGlobal: import("@scalar/typebox").TObject<{
+    'x-global': import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
+}>;
+//# sourceMappingURL=x-global.d.ts.map

package/dist/schemas/extensions/parameter/x-global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-global.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/parameter/x-global.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO;;EAElB,CAAA"}

package/dist/schemas/extensions/parameter/x-global.js

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

package/dist/schemas/extensions/parameter/x-global.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/extensions/parameter/x-global.ts"],
+  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\n/**\n * OpenAPI extension used by the api-client application to determine if a parameter is considered global in scope\n * for the entire workspace. When set, this parameter will be injected into every request automatically.\n *\n * @example\n * ```yaml\n * x-global: true\n * ```\n */\nexport const XGlobal = Type.Object({\n  'x-global': Type.Optional(Type.Boolean()),\n})\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAWd,MAAM,UAAU,KAAK,OAAO;AAAA,EACjC,YAAY,KAAK,SAAS,KAAK,QAAQ,CAAC;AAC1C,CAAC;",
+  "names": []
+}

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

@@ -8,4 +8,14 @@
 export declare const XAdditionalPropertiesNameSchema: import("@scalar/typebox").TObject<{
     'x-additionalPropertiesName': import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
 }>;
+export type XAdditionalPropertiesName = {
+    /**
+     * 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.
+     */
+    'x-additionalPropertiesName'?: string;
+};
 //# sourceMappingURL=x-additional-properties-name.d.ts.map

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

@@ -1 +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"}
+{"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;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;;OAMG;IACH,4BAA4B,CAAC,EAAE,MAAM,CAAA;CACtC,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/schema/x-additional-properties-name.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/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"],
+  "sourcesContent": ["import { Type } from '@scalar/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\nexport type XAdditionalPropertiesName = {\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   */\n  'x-additionalPropertiesName'?: 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

@@ -15,4 +15,34 @@ export declare const XEnumDescriptionsSchema: import("@scalar/typebox").TObject<
     'x-enumDescriptions': import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>, import("@scalar/typebox").TArray<import("@scalar/typebox").TString>]>>;
     'x-enum-descriptions': import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>, import("@scalar/typebox").TArray<import("@scalar/typebox").TString>]>>;
 }>;
+export type XEnumDescriptions = {
+    /**
+     * 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"
+     */
+    'x-enumDescriptions'?: Record<string, string> | string[];
+    /**
+     * x-enum-descriptions
+     *
+     * 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-enum-descriptions:
+     *   missing_features: "Missing features"
+     *   too_expensive: "Too expensive"
+     *   unused: "Unused"
+     *   other: "Other"
+     */
+    'x-enum-descriptions'?: Record<string, string> | string[];
+};
 //# sourceMappingURL=x-enum-descriptions.d.ts.map

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

@@ -1 +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;;;EAOlC,CAAA"}
+{"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;;;EAOlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;;;;;OAYG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,CAAA;IACxD;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,CAAA;CAC1D,CAAA"}

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/schemas/extensions/schema/x-enum-descriptions.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/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(\n    Type.Union([Type.Record(Type.String(), Type.String()), Type.Array(Type.String())]),\n  ),\n  'x-enum-descriptions': Type.Optional(\n    Type.Union([Type.Record(Type.String(), Type.String()), Type.Array(Type.String())]),\n  ),\n})\n"],
+  "sourcesContent": ["import { Type } from '@scalar/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(\n    Type.Union([Type.Record(Type.String(), Type.String()), Type.Array(Type.String())]),\n  ),\n  'x-enum-descriptions': Type.Optional(\n    Type.Union([Type.Record(Type.String(), Type.String()), Type.Array(Type.String())]),\n  ),\n})\n\nexport type XEnumDescriptions = {\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   */\n  'x-enumDescriptions'?: Record<string, string> | string[]\n  /**\n   * x-enum-descriptions\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-enum-descriptions:\n   *   missing_features: \"Missing features\"\n   *   too_expensive: \"Too expensive\"\n   *   unused: \"Unused\"\n   *   other: \"Other\"\n   */\n  'x-enum-descriptions'?: Record<string, string> | string[]\n}\n"],
   "mappings": "AAAA,SAAS,YAAY;AAed,MAAM,0BAA0B,KAAK,OAAO;AAAA,EACjD,sBAAsB,KAAK;AAAA,IACzB,KAAK,MAAM,CAAC,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,OAAO,CAAC,GAAG,KAAK,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC;AAAA,EACnF;AAAA,EACA,uBAAuB,KAAK;AAAA,IAC1B,KAAK,MAAM,CAAC,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,OAAO,CAAC,GAAG,KAAK,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC;AAAA,EACnF;AACF,CAAC;",
   "names": []
 }

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

@@ -19,4 +19,42 @@ export declare const XEnumVarNamesSchema: import("@scalar/typebox").TObject<{
     'x-enum-varnames': import("@scalar/typebox").TOptional<import("@scalar/typebox").TArray<import("@scalar/typebox").TString>>;
     'x-enumNames': import("@scalar/typebox").TOptional<import("@scalar/typebox").TArray<import("@scalar/typebox").TString>>;
 }>;
+export type XEnumVarNames = {
+    /**
+     * x-enum-varnames
+     *
+     * Names the enum values, must be in the same order as the enum values.
+     *
+     * @example
+     * ```yaml
+     * enum:
+     *   - moon
+     *   - asteroid
+     *   - comet
+     * x-enum-varnames:
+     *   - Moon
+     *   - Asteroid
+     *   - Comet
+     * ```
+     */
+    'x-enum-varnames'?: string[];
+    /**
+     * x-enumNames
+     *
+     * Names the enum values, must be in the same order as the enum values.
+     *
+     * @example
+     * ```yaml
+     * enum:
+     *   - moon
+     *   - asteroid
+     *   - comet
+     * x-enumNames:
+     *   - Moon
+     *   - Asteroid
+     *   - Comet
+     * ```
+     */
+    'x-enumNames'?: string[];
+};
 //# sourceMappingURL=x-enum-varnames.d.ts.map