@scalar/workspace-store 0.41.2 → 0.42.0

package/dist/schemas/extensions/general/x-scalar-cookies.js

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, boolean, object, optional, string } from '@scalar/validation';
 export const xScalarCookieSchema = Type.Object({
     name: Type.String(),
     value: Type.String(),
@@ -6,6 +7,24 @@ export const xScalarCookieSchema = Type.Object({
     path: Type.Optional(Type.String()),
     isDisabled: Type.Optional(Type.Boolean()),
 });
+export const XScalarCookie = object({
+    name: string({ typeComment: 'Defines the cookie name and its value.' }),
+    value: string({ typeComment: 'Defines the cookie value.' }),
+    domain: optional(string({ typeComment: 'Allows this domain and all subdomains.' })),
+    path: optional(string({ typeComment: 'Restricts this cookie to requests that contain this path.' })),
+    isDisabled: optional(boolean({ typeComment: 'Indicates if the cookie is disabled.' })),
+}, {
+    typeName: 'XScalarCookie',
+    typeComment: 'A persisted cookie definition for the workspace',
+});
 export const xScalarCookiesSchema = Type.Object({
     'x-scalar-cookies': Type.Optional(Type.Array(xScalarCookieSchema)),
 });
+export const XScalarCookies = object({
+    'x-scalar-cookies': optional(array(XScalarCookie, {
+        typeComment: 'Cookies persisted for the workspace',
+    })),
+}, {
+    typeName: 'XScalarCookies',
+    typeComment: 'Persisted workspace cookies',
+});

package/dist/schemas/extensions/general/x-scalar-order.d.ts

@@ -9,4 +9,7 @@ export declare const XScalarOrderSchema: import("@scalar/typebox").TObject<{
 export type XScalarOrder = {
     'x-scalar-order'?: string[];
 };
+export declare const XScalarOrder: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>;
 //# sourceMappingURL=x-scalar-order.d.ts.map

package/dist/schemas/extensions/general/x-scalar-order.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-order.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/general/x-scalar-order.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;EAE7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA"}
+{"version":3,"file":"x-scalar-order.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/general/x-scalar-order.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;EAE7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,eAAO,MAAM,YAAY;;EAQxB,CAAA"}

package/dist/schemas/extensions/general/x-scalar-order.js

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, string } from '@scalar/validation';
 /**
  * Schema for the "x-scalar-order" OpenAPI extension.
  * This extension allows specifying an optional array of strings,
@@ -7,3 +8,9 @@ import { Type } from '@scalar/typebox';
 export const XScalarOrderSchema = Type.Object({
     'x-scalar-order': Type.Optional(Type.Array(Type.String())),
 });
+export const XScalarOrder = object({
+    'x-scalar-order': optional(array(string())),
+}, {
+    typeName: 'XScalarOrder',
+    typeComment: 'Custom order for elements in the Scalar UI',
+});

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

@@ -34,6 +34,11 @@ export type XBadge = {
      */
     color?: string;
 };
+export declare const XBadge: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    position: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"before"> | import("@scalar/validation").LiteralSchema<"after">)[]>>;
+    color: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
 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:
@@ -95,4 +100,11 @@ export type XBadges = {
      */
     'x-badges'?: XBadge[];
 };
+export declare const XBadges: import("@scalar/validation").ObjectSchema<{
+    'x-badges': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        position: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"before"> | import("@scalar/validation").LiteralSchema<"after">)[]>>;
+        color: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>>;
+}>;
 //# 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":"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"}
+{"version":3,"file":"x-badge.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-badge.ts"],"names":[],"mappings":"AAGA;;;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,MAAM;;;;EAoBlB,CAAA;AAED,eAAO,MAAM,aAAa;IACxB;;;;;;;;;;;;;;;;;;;;OAoBG;;QA9FD,4EAA4E;;QAK5E;;;WAGG;;QAOH;;;WAGG;;;EA8EL,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,OAAO;;;;;;EAYnB,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, literal, object, optional, string, union } from '@scalar/validation';
 /**
  * Schema for individual badge configuration in x-badges extension.
  * Badges are indicators that can be displayed in API documentation.
@@ -28,6 +29,20 @@ export const XBadgeSchema = Type.Object({
 }, {
     description: 'Configuration for a single badge in the x-badges extension',
 });
+export const XBadge = object({
+    name: string({
+        typeComment: 'The text that displays in the badge. This is required for all badges.',
+    }),
+    position: optional(union([literal('before'), literal('after')], {
+        typeComment: 'The position of the badge in relation to the header',
+    })),
+    color: optional(string({
+        typeComment: 'The color of the badge in various formats (keywords, RGB, RGBA, HSL, HSLA, Hexadecimal)',
+    })),
+}, {
+    typeName: 'XBadge',
+    typeComment: 'Configuration for a single badge in the x-badges extension',
+});
 export const XBadgesSchema = Type.Object({
     /**
      * 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:
@@ -52,3 +67,11 @@ export const XBadgesSchema = Type.Object({
      */
     'x-badges': Type.Optional(Type.Array(XBadgeSchema)),
 });
+export const XBadges = object({
+    'x-badges': optional(array(XBadge, {
+        typeComment: 'Badges displayed for this operation in documentation',
+    })),
+}, {
+    typeName: 'XBadges',
+    typeComment: 'Badges for an operation in the Scalar UI',
+});

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

@@ -20,9 +20,31 @@ export type XCodeSample = {
     label?: string;
     source: string;
 };
+export declare const XCodeSample: import("@scalar/validation").ObjectSchema<{
+    lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    source: import("@scalar/validation").StringSchema;
+}>;
 export type XCodeSamples = {
     'x-codeSamples'?: XCodeSample[];
     'x-code-samples'?: XCodeSample[];
     'x-custom-examples'?: XCodeSample[];
 };
+export declare const XCodeSamples: import("@scalar/validation").ObjectSchema<{
+    'x-codeSamples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
+    'x-code-samples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
+    'x-custom-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
+}>;
 //# 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":"AAQA,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"}
+{"version":3,"file":"x-code-samples.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-code-samples.ts"],"names":[],"mappings":"AASA,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,eAAO,MAAM,WAAW;;;;EAUvB,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;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAUxB,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, string } from '@scalar/validation';
 const XCodeSampleSchema = Type.Object({
     lang: Type.Optional(Type.String()),
     label: Type.Optional(Type.String()),
@@ -9,3 +10,19 @@ export const XCodeSamplesSchema = Type.Object({
     'x-code-samples': Type.Optional(Type.Array(XCodeSampleSchema)),
     'x-custom-examples': Type.Optional(Type.Array(XCodeSampleSchema)),
 });
+export const XCodeSample = object({
+    lang: optional(string()),
+    label: optional(string()),
+    source: string(),
+}, {
+    typeName: 'XCodeSample',
+    typeComment: 'A single code sample for documentation or examples',
+});
+export const XCodeSamples = object({
+    'x-codeSamples': optional(array(XCodeSample)),
+    'x-code-samples': optional(array(XCodeSample)),
+    'x-custom-examples': optional(array(XCodeSample)),
+}, {
+    typeName: 'XCodeSamples',
+    typeComment: 'Code samples attached to an operation',
+});

package/dist/schemas/extensions/operation/x-draft-examples.d.ts

@@ -4,4 +4,7 @@ export declare const XDraftExamplesSchema: import("@scalar/typebox").TObject<{
 export type XDraftExamples = {
     'x-draft-examples'?: string[];
 };
+export declare const XDraftExamples: import("@scalar/validation").ObjectSchema<{
+    'x-draft-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>;
 //# sourceMappingURL=x-draft-examples.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-draft-examples.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-draft-examples.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC9B,CAAA"}
+{"version":3,"file":"x-draft-examples.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-draft-examples.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,cAAc;;EAQ1B,CAAA"}

package/dist/schemas/extensions/operation/x-draft-examples.js

@@ -1,4 +1,11 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, string } from '@scalar/validation';
 export const XDraftExamplesSchema = Type.Object({
     'x-draft-examples': Type.Optional(Type.Array(Type.String())),
 });
+export const XDraftExamples = object({
+    'x-draft-examples': optional(array(string())),
+}, {
+    typeName: 'XDraftExamples',
+    typeComment: 'Draft example identifiers for an operation',
+});

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

@@ -34,4 +34,7 @@ export type XPostResponse = {
      */
     'x-post-response'?: string;
 };
+export declare const XPostResponse: import("@scalar/validation").ObjectSchema<{
+    'x-post-response': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
 //# 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;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA"}
+{"version":3,"file":"x-post-response.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-post-response.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB;;EAE9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,aAAa;;EAYzB,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { object, optional, string } from '@scalar/validation';
 /**
  * Post response scripts allow to execute arbitrary code after a response is received
  *
@@ -17,3 +18,11 @@ import { Type } from '@scalar/typebox';
 export const XPostResponseSchema = Type.Object({
     'x-post-response': Type.Optional(Type.String()),
 });
+export const XPostResponse = object({
+    'x-post-response': optional(string({
+        typeComment: 'Script to run after a response is received',
+    })),
+}, {
+    typeName: 'XPostResponse',
+    typeComment: 'Post-response script for an operation',
+});

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

@@ -107,5 +107,14 @@ export declare const XScalarDisableParametersSchema: import("@scalar/typebox").T
 export type XScalarDisableParameters = {
     'x-scalar-disable-parameters'?: DisableParametersConfig;
 };
+declare const ExampleParameterState: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>;
+declare const ExamplesParameterStates: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>>;
+export declare const XScalarDisableParameters: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-disable-parameters': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        'global-cookies': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>>>;
+        'global-headers': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>>>;
+        'default-headers': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>>>;
+    }>>;
+}>;
 export {};
 //# sourceMappingURL=x-scalar-disable-parameters.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-disable-parameters.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-scalar-disable-parameters.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,KAAK,aAAa,GAAG,MAAM,CAAA;AAE3B;;;GAGG;AACH,KAAK,UAAU,GAAG,MAAM,CAAA;AAExB;;;;;;;;;GASG;AACH,KAAK,qBAAqB,GAAG,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAA;AAE3D;;;;;;;;;GASG;AACH,KAAK,uBAAuB,GAAG,MAAM,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAA;AAExE;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,uBAAuB,CAAA;IAC1C;;;OAGG;IACH,gBAAgB,CAAC,EAAE,uBAAuB,CAAA;IAC1C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,uBAAuB,CAAA;CAC5C,CAAA;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,8BAA8B;;;;;;EAQzC,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,6BAA6B,CAAC,EAAE,uBAAuB,CAAA;CACxD,CAAA"}
+{"version":3,"file":"x-scalar-disable-parameters.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-scalar-disable-parameters.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,KAAK,aAAa,GAAG,MAAM,CAAA;AAE3B;;;GAGG;AACH,KAAK,UAAU,GAAG,MAAM,CAAA;AAExB;;;;;;;;;GASG;AACH,KAAK,qBAAqB,GAAG,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAA;AAE3D;;;;;;;;;GASG;AACH,KAAK,uBAAuB,GAAG,MAAM,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAA;AAExE;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,uBAAuB,CAAA;IAC1C;;;OAGG;IACH,gBAAgB,CAAC,EAAE,uBAAuB,CAAA;IAC1C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,uBAAuB,CAAA;CAC5C,CAAA;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,8BAA8B;;;;;;EAQzC,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,6BAA6B,CAAC,EAAE,uBAAuB,CAAA;CACxD,CAAA;AAED,QAAA,MAAM,qBAAqB,kIAA8B,CAAA;AAEzD,QAAA,MAAM,uBAAuB,wNAA0C,CAAA;AAcvE,eAAO,MAAM,wBAAwB;;;;;;EAQpC,CAAA"}

package/dist/schemas/extensions/operation/x-scalar-disable-parameters.js

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { boolean, object, optional, record, string } from '@scalar/validation';
 /**
  * Schema for parameter disabled states within a single example.
  * Maps parameter names (strings) to their disabled state (boolean).
@@ -58,3 +59,19 @@ export const XScalarDisableParametersSchema = Type.Object({
         'default-headers': Type.Optional(ExamplesParameterStatesSchema),
     })),
 });
+const ExampleParameterState = record(string(), boolean());
+const ExamplesParameterStates = record(string(), ExampleParameterState);
+const DisableParametersInner = object({
+    'global-cookies': optional(ExamplesParameterStates),
+    'global-headers': optional(ExamplesParameterStates),
+    'default-headers': optional(ExamplesParameterStates),
+}, {
+    typeName: 'DisableParametersConfig',
+    typeComment: 'Disabled parameter state by category and example',
+});
+export const XScalarDisableParameters = object({
+    'x-scalar-disable-parameters': optional(DisableParametersInner),
+}, {
+    typeName: 'XScalarDisableParameters',
+    typeComment: 'Tracks which parameters are disabled across examples',
+});

package/dist/schemas/extensions/operation/x-scalar-selected-content-type.d.ts

@@ -18,4 +18,7 @@ export type XScalarSelectedContentType = {
         [key: string]: string;
     };
 };
+export declare const XScalarSelectedContentType: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-selected-content-type': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+}>;
 //# sourceMappingURL=x-scalar-selected-content-type.d.ts.map

package/dist/schemas/extensions/operation/x-scalar-selected-content-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-selected-content-type.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-scalar-selected-content-type.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC;;EAE3C,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,gCAAgC,CAAC,EAAE;QACjC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KACtB,CAAA;CACF,CAAA"}
+{"version":3,"file":"x-scalar-selected-content-type.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-scalar-selected-content-type.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC;;EAE3C,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,gCAAgC,CAAC,EAAE;QACjC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KACtB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,0BAA0B;;EAYtC,CAAA"}

package/dist/schemas/extensions/operation/x-scalar-selected-content-type.js

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { object, optional, record, string } from '@scalar/validation';
 /**
  * Schema for the x-scalar-selected-content-type extension on an OpenAPI operation.
  *
@@ -8,3 +9,11 @@ import { Type } from '@scalar/typebox';
 export const XScalarSelectedContentTypeSchema = Type.Object({
     'x-scalar-selected-content-type': Type.Optional(Type.Record(Type.String(), Type.String())),
 });
+export const XScalarSelectedContentType = object({
+    'x-scalar-selected-content-type': optional(record(string(), string(), {
+        typeComment: 'Selected content type per example name',
+    })),
+}, {
+    typeName: 'XScalarSelectedContentType',
+    typeComment: 'Selected content type per example for request or response bodies',
+});

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

@@ -26,4 +26,7 @@ export type XScalarStability = {
      */
     'x-scalar-stability'?: XScalarStabilityValues;
 };
+export declare const XScalarStability: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-stability': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").LiteralSchema<"deprecated"> | import("@scalar/validation").LiteralSchema<"experimental"> | import("@scalar/validation").LiteralSchema<"stable">)[]>>;
+}>;
 //# 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;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,sBAAsB,CAAA;CAC9C,CAAA"}
+{"version":3,"file":"x-scalar-stability.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/x-scalar-stability.ts"],"names":[],"mappings":"AAGA,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;AAED,eAAO,MAAM,gBAAgB;;EAY5B,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { literal, object, optional, union } from '@scalar/validation';
 export const XScalarStabilityValues = {
     Deprecated: 'deprecated',
     Experimental: 'experimental',
@@ -15,3 +16,11 @@ export const XScalarStabilityValues = {
 export const XScalarStabilitySchema = Type.Object({
     'x-scalar-stability': Type.Optional(Type.Union([Type.Literal('deprecated'), Type.Literal('experimental'), Type.Literal('stable')])),
 });
+export const XScalarStability = object({
+    'x-scalar-stability': optional(union([literal('deprecated'), literal('experimental'), literal('stable')], {
+        typeComment: 'Stability level of the operation',
+    })),
+}, {
+    typeName: 'XScalarStability',
+    typeComment: 'Stability of the operation in the Scalar UI',
+});

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

@@ -7,7 +7,13 @@
  * x-global: true
  * ```
  */
-export declare const XGlobal: import("@scalar/typebox").TObject<{
+export declare const XGlobalSchema: import("@scalar/typebox").TObject<{
     'x-global': import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
 }>;
+export type XGlobal = {
+    'x-global'?: boolean;
+};
+export declare const XGlobal: import("@scalar/validation").ObjectSchema<{
+    'x-global': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>;
 //# sourceMappingURL=x-global.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"x-global.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/parameter/x-global.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;EAExB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,OAAO;;EAQnB,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { boolean, object, optional } from '@scalar/validation';
 /**
  * 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.
@@ -8,6 +9,12 @@ import { Type } from '@scalar/typebox';
  * x-global: true
  * ```
  */
-export const XGlobal = Type.Object({
+export const XGlobalSchema = Type.Object({
     'x-global': Type.Optional(Type.Boolean()),
 });
+export const XGlobal = object({
+    'x-global': optional(boolean()),
+}, {
+    typeName: 'XGlobal',
+    typeComment: 'When true, the parameter is injected into every request for the workspace',
+});

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

@@ -18,4 +18,7 @@ export type XAdditionalPropertiesName = {
      */
     'x-additionalPropertiesName'?: string;
 };
+export declare const XAdditionalPropertiesName: import("@scalar/validation").ObjectSchema<{
+    'x-additionalPropertiesName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
 //# 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;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;;OAMG;IACH,4BAA4B,CAAC,EAAE,MAAM,CAAA;CACtC,CAAA"}
+{"version":3,"file":"x-additional-properties-name.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-additional-properties-name.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;EAE1C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;;OAMG;IACH,4BAA4B,CAAC,EAAE,MAAM,CAAA;CACtC,CAAA;AAED,eAAO,MAAM,yBAAyB;;EAQrC,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { object, optional, string } from '@scalar/validation';
 /**
  * x-additionalPropertiesName
  *
@@ -9,3 +10,9 @@ import { Type } from '@scalar/typebox';
 export const XAdditionalPropertiesNameSchema = Type.Object({
     'x-additionalPropertiesName': Type.Optional(Type.String()),
 });
+export const XAdditionalPropertiesName = object({
+    'x-additionalPropertiesName': optional(string()),
+}, {
+    typeName: 'XAdditionalPropertiesName',
+    typeComment: 'Display name for additional properties on a schema',
+});

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

@@ -45,4 +45,8 @@ export type XEnumDescriptions = {
      */
     'x-enum-descriptions'?: Record<string, string> | string[];
 };
+export declare const XEnumDescriptions: import("@scalar/validation").ObjectSchema<{
+    'x-enumDescriptions': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema> | import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>)[]>>;
+    'x-enum-descriptions': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<(import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema> | import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>)[]>>;
+}>;
 //# 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;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"}
+{"version":3,"file":"x-enum-descriptions.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-enum-descriptions.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;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;AAID,eAAO,MAAM,iBAAiB;;;EAS7B,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, record, string, union } from '@scalar/validation';
 /**
  * x-enumDescriptions
  *
@@ -16,3 +17,11 @@ export const XEnumDescriptionsSchema = Type.Object({
     'x-enumDescriptions': Type.Optional(Type.Union([Type.Record(Type.String(), Type.String()), Type.Array(Type.String())])),
     'x-enum-descriptions': Type.Optional(Type.Union([Type.Record(Type.String(), Type.String()), Type.Array(Type.String())])),
 });
+const enumDescriptionValue = union([record(string(), string()), array(string())]);
+export const XEnumDescriptions = object({
+    'x-enumDescriptions': optional(enumDescriptionValue),
+    'x-enum-descriptions': optional(enumDescriptionValue),
+}, {
+    typeName: 'XEnumDescriptions',
+    typeComment: 'Descriptions for enum values',
+});

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

@@ -57,4 +57,8 @@ export type XEnumVarNames = {
      */
     'x-enumNames'?: string[];
 };
+export declare const XEnumVarNames: import("@scalar/validation").ObjectSchema<{
+    'x-enum-varnames': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    'x-enumNames': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>;
 //# sourceMappingURL=x-enum-varnames.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-enum-varnames.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-enum-varnames.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B;;;;;;;;;;;;;;;;OAgBG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA"}
+{"version":3,"file":"x-enum-varnames.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-enum-varnames.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B;;;;;;;;;;;;;;;;OAgBG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,aAAa;;;EASzB,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, string } from '@scalar/validation';
 /**
  * x-enum-varnames
  *
@@ -20,3 +21,10 @@ export const XEnumVarNamesSchema = Type.Object({
     'x-enum-varnames': Type.Optional(Type.Array(Type.String())),
     'x-enumNames': Type.Optional(Type.Array(Type.String())),
 });
+export const XEnumVarNames = object({
+    'x-enum-varnames': optional(array(string())),
+    'x-enumNames': optional(array(string())),
+}, {
+    typeName: 'XEnumVarNames',
+    typeComment: 'Display names for enum values',
+});

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

@@ -7,4 +7,7 @@ export type XExamples = {
      */
     'x-examples'?: Record<string, unknown>;
 };
+export declare const XExamples: import("@scalar/validation").ObjectSchema<{
+    'x-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema>>;
+}>;
 //# sourceMappingURL=x-examples.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-examples.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-examples.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;EAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC,CAAA"}
+{"version":3,"file":"x-examples.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-examples.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;EAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC,CAAA;AAED,eAAO,MAAM,SAAS;;EAQrB,CAAA"}

package/dist/schemas/extensions/schema/x-examples.js

@@ -1,4 +1,11 @@
 import { Type } from '@scalar/typebox';
+import { any, object, optional, record, string } from '@scalar/validation';
 export const XExamplesSchema = Type.Object({
     'x-examples': Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 });
+export const XExamples = object({
+    'x-examples': optional(record(string(), any())),
+}, {
+    typeName: 'XExamples',
+    typeComment: 'Named examples attached to a schema',
+});

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

@@ -4,4 +4,7 @@ export declare const XVariableSchema: import("@scalar/typebox").TObject<{
 export type XVariable = {
     'x-variable'?: string;
 };
+export declare const XVariable: import("@scalar/validation").ObjectSchema<{
+    'x-variable': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
 //# sourceMappingURL=x-variable.d.ts.map

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

@@ -1 +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;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA"}
+{"version":3,"file":"x-variable.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/schema/x-variable.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;EAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,SAAS;;EAQrB,CAAA"}

package/dist/schemas/extensions/schema/x-variable.js

@@ -1,4 +1,11 @@
 import { Type } from '@scalar/typebox';
+import { object, optional, string } from '@scalar/validation';
 export const XVariableSchema = Type.Object({
     'x-variable': Type.Optional(Type.String()),
 });
+export const XVariable = object({
+    'x-variable': optional(string()),
+}, {
+    typeName: 'XVariable',
+    typeComment: 'Variable reference for a schema property',
+});

package/dist/schemas/extensions/security/x-default-scopes.d.ts

@@ -30,4 +30,7 @@ export type XDefaultScopes = {
      */
     'x-default-scopes'?: string[];
 };
+export declare const XDefaultScopes: import("@scalar/validation").ObjectSchema<{
+    'x-default-scopes': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>;
 //# sourceMappingURL=x-default-scopes.d.ts.map

package/dist/schemas/extensions/security/x-default-scopes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-default-scopes.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/security/x-default-scopes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC9B,CAAA"}
+{"version":3,"file":"x-default-scopes.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/security/x-default-scopes.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,cAAc;;EAQ1B,CAAA"}

package/dist/schemas/extensions/security/x-default-scopes.js

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, string } from '@scalar/validation';
 /**
  * Default selected scopes for the oauth flow
  *
@@ -15,3 +16,9 @@ import { Type } from '@scalar/typebox';
 export const XDefaultScopesSchema = Type.Object({
     'x-default-scopes': Type.Optional(Type.Array(Type.String())),
 });
+export const XDefaultScopes = object({
+    'x-default-scopes': optional(array(string())),
+}, {
+    typeName: 'XDefaultScopes',
+    typeComment: 'Default selected OAuth scopes',
+});