@scalar/workspace-store 0.40.2 → 0.40.4

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

@@ -1,62 +1,54 @@
-import { Type } from "@scalar/typebox";
-const XBadgeSchema = Type.Object(
-  {
+import { Type } from '@scalar/typebox';
+/**
+ * Schema for individual badge configuration in x-badges extension.
+ * Badges are indicators that can be displayed in API documentation.
+ */
+export const XBadgeSchema = 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
+        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"
-      })
-    ),
+    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({
-  /**
-   * 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))
+    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',
+});
+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:
+     *
+     * ```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 {
-  XBadgeSchema,
-  XBadgesSchema
-};
-//# sourceMappingURL=x-badge.js.map

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

@@ -1,15 +1,11 @@
-import { Type } from "@scalar/typebox";
+import { Type } from '@scalar/typebox';
 const XCodeSampleSchema = Type.Object({
-  lang: Type.Optional(Type.String()),
-  label: Type.Optional(Type.String()),
-  source: Type.String()
+    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 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 {
-  XCodeSamplesSchema
-};
-//# sourceMappingURL=x-code-samples.js.map

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

@@ -1,8 +1,4 @@
-import { Type } from "@scalar/typebox";
-const XDraftExamplesSchema = Type.Object({
-  "x-draft-examples": Type.Optional(Type.Array(Type.String()))
+import { Type } from '@scalar/typebox';
+export const XDraftExamplesSchema = Type.Object({
+    'x-draft-examples': Type.Optional(Type.Array(Type.String())),
 });
-export {
-  XDraftExamplesSchema
-};
-//# sourceMappingURL=x-draft-examples.js.map

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

@@ -1,8 +1,19 @@
-import { Type } from "@scalar/typebox";
-const XPostResponseSchema = Type.Object({
-  "x-post-response": Type.Optional(Type.String())
+import { Type } from '@scalar/typebox';
+/**
+ * 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 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-scalar-disable-parameters.js

@@ -1,16 +1,60 @@
-import { Type } from "@scalar/typebox";
+import { Type } from '@scalar/typebox';
+/**
+ * Schema for parameter disabled states within a single example.
+ * Maps parameter names (strings) to their disabled state (boolean).
+ */
 const ExampleParameterStateSchema = Type.Record(Type.String(), Type.Boolean());
+/**
+ * Schema for all example parameter states across multiple examples.
+ * Maps example keys (strings) to their parameter disabled states.
+ */
 const ExamplesParameterStatesSchema = Type.Record(Type.String(), ExampleParameterStateSchema);
-const XScalarDisableParametersSchema = Type.Object({
-  "x-scalar-disable-parameters": Type.Optional(
-    Type.Object({
-      "global-cookies": Type.Optional(ExamplesParameterStatesSchema),
-      "global-headers": Type.Optional(ExamplesParameterStatesSchema),
-      "default-headers": Type.Optional(ExamplesParameterStatesSchema)
-    })
-  )
+/**
+ * Custom OpenAPI extension to track which parameters are disabled across different contexts.
+ *
+ * This extension allows the API client to persist disabled states for different types of
+ * parameters (global cookies, global headers, default headers) across multiple examples.
+ *
+ * This is necessary because:
+ * - Different parameter types have different scopes and behaviors
+ * - Users need to disable specific parameters per example without affecting others
+ * - The disabled state must persist across sessions
+ * - Global parameters can be disabled independently of operation-specific ones
+ *
+ * Structure:
+ * - Top level: Parameter category ("global-cookies", "global-headers", "default-headers")
+ * - Second level: Example keys (like "default", "custom-example")
+ * - Third level: Parameter names (like "Content-Type", "Cookie")
+ * - Values: true = disabled, false = enabled
+ *
+ * @example
+ * ```json
+ * {
+ *   "x-scalar-disable-parameters": {
+ *     "global-cookies": {
+ *       "default": {
+ *         "session": true
+ *       }
+ *     },
+ *     "global-headers": {
+ *       "default": {
+ *         "X-API-Key": false
+ *       }
+ *     },
+ *     "default-headers": {
+ *       "default": {
+ *         "Content-Type": true,
+ *         "Accept": false
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export const XScalarDisableParametersSchema = Type.Object({
+    'x-scalar-disable-parameters': Type.Optional(Type.Object({
+        'global-cookies': Type.Optional(ExamplesParameterStatesSchema),
+        'global-headers': Type.Optional(ExamplesParameterStatesSchema),
+        'default-headers': Type.Optional(ExamplesParameterStatesSchema),
+    })),
 });
-export {
-  XScalarDisableParametersSchema
-};
-//# sourceMappingURL=x-scalar-disable-parameters.js.map

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

@@ -1,8 +1,10 @@
-import { Type } from "@scalar/typebox";
-const XScalarSelectedContentTypeSchema = Type.Object({
-  "x-scalar-selected-content-type": Type.Optional(Type.Record(Type.String(), Type.String()))
+import { Type } from '@scalar/typebox';
+/**
+ * Schema for the x-scalar-selected-content-type extension on an OpenAPI operation.
+ *
+ * The key represents the example name, and the value is the selected content type string.
+ * Used by Scalar to track which content type is selected for each example in request or response bodies.
+ */
+export const XScalarSelectedContentTypeSchema = Type.Object({
+    'x-scalar-selected-content-type': Type.Optional(Type.Record(Type.String(), Type.String())),
 });
-export {
-  XScalarSelectedContentTypeSchema
-};
-//# sourceMappingURL=x-scalar-selected-content-type.js.map

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

@@ -1,16 +1,17 @@
-import { Type } from "@scalar/typebox";
-const XScalarStabilityValues = {
-  Deprecated: "deprecated",
-  Experimental: "experimental",
-  Stable: "stable"
+import { Type } from '@scalar/typebox';
+export 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")])
-  )
+/**
+ * An OpenAPI extension to indicate the stability of the operation
+ *
+ * @example
+ * ```yaml
+ * x-scalar-stability: deprecated
+ * ```
+ */
+export 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/parameter/x-global.js

@@ -1,8 +1,13 @@
-import { Type } from "@scalar/typebox";
-const XGlobal = Type.Object({
-  "x-global": Type.Optional(Type.Boolean())
+import { Type } from '@scalar/typebox';
+/**
+ * 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 const XGlobal = Type.Object({
+    'x-global': Type.Optional(Type.Boolean()),
 });
-export {
-  XGlobal
-};
-//# sourceMappingURL=x-global.js.map

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

@@ -1,8 +1,11 @@
-import { Type } from "@scalar/typebox";
-const XAdditionalPropertiesNameSchema = Type.Object({
-  "x-additionalPropertiesName": Type.Optional(Type.String())
+import { Type } from '@scalar/typebox';
+/**
+ * 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 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-enum-descriptions.js

@@ -1,13 +1,18 @@
-import { Type } from "@scalar/typebox";
-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())])
-  )
+import { Type } from '@scalar/typebox';
+/**
+ * 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 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())])),
 });
-export {
-  XEnumDescriptionsSchema
-};
-//# sourceMappingURL=x-enum-descriptions.js.map

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

@@ -1,9 +1,22 @@
-import { Type } from "@scalar/typebox";
-const XEnumVarNamesSchema = Type.Object({
-  "x-enum-varnames": Type.Optional(Type.Array(Type.String())),
-  "x-enumNames": Type.Optional(Type.Array(Type.String()))
+import { Type } from '@scalar/typebox';
+/**
+ * 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
+ * ```
+ */
+export const XEnumVarNamesSchema = Type.Object({
+    'x-enum-varnames': Type.Optional(Type.Array(Type.String())),
+    'x-enumNames': Type.Optional(Type.Array(Type.String())),
 });
-export {
-  XEnumVarNamesSchema
-};
-//# sourceMappingURL=x-enum-varnames.js.map

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

@@ -1,8 +1,4 @@
-import { Type } from "@scalar/typebox";
-const XExamplesSchema = Type.Object({
-  "x-examples": Type.Optional(Type.Record(Type.String(), Type.Unknown()))
+import { Type } from '@scalar/typebox';
+export const XExamplesSchema = Type.Object({
+    'x-examples': Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 });
-export {
-  XExamplesSchema
-};
-//# sourceMappingURL=x-examples.js.map

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

@@ -1,8 +1,4 @@
-import { Type } from "@scalar/typebox";
-const XVariableSchema = Type.Object({
-  "x-variable": Type.Optional(Type.String())
+import { Type } from '@scalar/typebox';
+export const XVariableSchema = Type.Object({
+    'x-variable': Type.Optional(Type.String()),
 });
-export {
-  XVariableSchema
-};
-//# sourceMappingURL=x-variable.js.map

package/dist/schemas/extensions/security/index.js

@@ -1 +1 @@
-//# sourceMappingURL=index.js.map
+export {};

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

@@ -1,8 +1,17 @@
-import { Type } from "@scalar/typebox";
-const XDefaultScopesSchema = Type.Object({
-  "x-default-scopes": Type.Optional(Type.Array(Type.String()))
+import { Type } from '@scalar/typebox';
+/**
+ * Default selected scopes for the oauth flow
+ *
+ * @example
+ * ```json
+ * {
+ *   "x-default-scopes": [
+ *     "profile",
+ *     "email"
+ *   ]
+ * }
+ * ```
+ */
+export const XDefaultScopesSchema = Type.Object({
+    'x-default-scopes': Type.Optional(Type.Array(Type.String())),
 });
-export {
-  XDefaultScopesSchema
-};
-//# sourceMappingURL=x-default-scopes.js.map

package/dist/schemas/extensions/security/x-scalar-credentials-location.js

@@ -1,8 +1,17 @@
-import { Type } from "@scalar/typebox";
-const XScalarCredentialsLocationSchema = Type.Object({
-  "x-scalar-credentials-location": Type.Optional(Type.Union([Type.Literal("header"), Type.Literal("body")]))
+import { Type } from '@scalar/typebox';
+/**
+ * An OpenAPI extension to specify where OAuth2 credentials should be sent
+ *
+ * @example
+ * ```yaml
+ * x-scalar-credentials-location: header
+ * ```
+ *
+ * @example
+ * ```yaml
+ * x-scalar-credentials-location: body
+ * ```
+ */
+export const XScalarCredentialsLocationSchema = Type.Object({
+    'x-scalar-credentials-location': Type.Optional(Type.Union([Type.Literal('header'), Type.Literal('body')])),
 });
-export {
-  XScalarCredentialsLocationSchema
-};
-//# sourceMappingURL=x-scalar-credentials-location.js.map

package/dist/schemas/extensions/security/x-scalar-security-body.js

@@ -1,8 +1,15 @@
-import { Type } from "@scalar/typebox";
-const XScalarSecurityBodySchema = Type.Object({
-  "x-scalar-security-body": Type.Optional(Type.Record(Type.String(), Type.String()))
+import { Type } from '@scalar/typebox';
+/**
+ * An OpenAPI extension to set any additional body parameters for the OAuth token request
+ *
+ * @example
+ * ```yaml
+ * x-scalar-security-body: {
+ *   audience: 'https://api.example.com',
+ *   resource: 'user-profile'
+ * }
+ * ```
+ */
+export const XScalarSecurityBodySchema = Type.Object({
+    'x-scalar-security-body': Type.Optional(Type.Record(Type.String(), Type.String())),
 });
-export {
-  XScalarSecurityBodySchema
-};
-//# sourceMappingURL=x-scalar-security-body.js.map

package/dist/schemas/extensions/security/x-scalar-security-query.js

@@ -1,8 +1,15 @@
-import { Type } from "@scalar/typebox";
-const XScalarSecurityQuerySchema = Type.Object({
-  "x-scalar-security-query": Type.Optional(Type.Record(Type.String(), Type.String()))
+import { Type } from '@scalar/typebox';
+/**
+ * An OpenAPI extension set any query parameters for the OAuth authorize request
+ *
+ * @example
+ * ```yaml
+ * x-scalar-security-query: {
+ *   prompt: 'consent',
+ *   audience: 'scalar'
+ * }
+ * ```
+ */
+export const XScalarSecurityQuerySchema = Type.Object({
+    'x-scalar-security-query': Type.Optional(Type.Record(Type.String(), Type.String())),
 });
-export {
-  XScalarSecurityQuerySchema
-};
-//# sourceMappingURL=x-scalar-security-query.js.map

package/dist/schemas/extensions/security/x-scalar-security-secrets.js

@@ -1,37 +1,66 @@
-import { Type } from "@scalar/typebox";
-const XScalarSecretTokenSchema = Type.Object({
-  "x-scalar-secret-token": Type.String()
-});
-const XScalarSecretRefreshTokenSchema = Type.Object({
-  "x-scalar-secret-refresh-token": Type.Optional(Type.String())
-});
-const XScalarAuthUrlSchema = Type.Object({
-  "x-scalar-secret-auth-url": Type.Optional(Type.String())
-});
-const XScalarTokenUrlSchema = Type.Object({
-  "x-scalar-secret-token-url": Type.Optional(Type.String())
-});
-const XScalarSecretHTTPSchema = Type.Object({
-  "x-scalar-secret-username": Type.String(),
-  "x-scalar-secret-password": Type.String()
-});
-const XScalarSecretClientSecretSchema = Type.Object({
-  "x-scalar-secret-client-secret": Type.String()
-});
-const XScalarSecretClientIdSchema = Type.Object({
-  "x-scalar-secret-client-id": Type.String()
-});
-const XScalarSecretRedirectUriSchema = Type.Object({
-  "x-scalar-secret-redirect-uri": Type.String()
-});
-export {
-  XScalarAuthUrlSchema,
-  XScalarSecretClientIdSchema,
-  XScalarSecretClientSecretSchema,
-  XScalarSecretHTTPSchema,
-  XScalarSecretRedirectUriSchema,
-  XScalarSecretRefreshTokenSchema,
-  XScalarSecretTokenSchema,
-  XScalarTokenUrlSchema
-};
-//# sourceMappingURL=x-scalar-security-secrets.js.map
+import { Type } from '@scalar/typebox';
+/**
+ * A scalar secret token
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarSecretTokenSchema = Type.Object({
+    'x-scalar-secret-token': Type.String(),
+});
+/**
+ * OAuth refresh token
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarSecretRefreshTokenSchema = Type.Object({
+    'x-scalar-secret-refresh-token': Type.Optional(Type.String()),
+});
+/**
+ * OAuth auth url
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarAuthUrlSchema = Type.Object({
+    'x-scalar-secret-auth-url': Type.Optional(Type.String()),
+});
+/**
+ * OAuth token url
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarTokenUrlSchema = Type.Object({
+    'x-scalar-secret-token-url': Type.Optional(Type.String()),
+});
+/**
+ * Username and password for HTTP authentication
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarSecretHTTPSchema = Type.Object({
+    'x-scalar-secret-username': Type.String(),
+    'x-scalar-secret-password': Type.String(),
+});
+/**
+ * Oauth client secret
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarSecretClientSecretSchema = Type.Object({
+    'x-scalar-secret-client-secret': Type.String(),
+});
+/**
+ * Oauth client ID
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarSecretClientIdSchema = Type.Object({
+    'x-scalar-secret-client-id': Type.String(),
+});
+/**
+ * Oauth Redirect URI
+ *
+ * We should not export this when exporting the document
+ */
+export const XScalarSecretRedirectUriSchema = Type.Object({
+    'x-scalar-secret-redirect-uri': Type.String(),
+});

package/dist/schemas/extensions/security/x-tokenName.js

@@ -1,8 +1,12 @@
-import { Type } from "@scalar/typebox";
-const XTokenNameSchema = Type.Object({
-  "x-tokenName": Type.Optional(Type.String())
+import { Type } from '@scalar/typebox';
+/**
+ * An OpenAPI extension to specify a custom token name for OAuth2 flows
+ *
+ * @example
+ * ```yaml
+ * x-tokenName: 'custom_access_token'
+ * ```
+ */
+export const XTokenNameSchema = Type.Object({
+    'x-tokenName': Type.Optional(Type.String()),
 });
-export {
-  XTokenNameSchema
-};
-//# sourceMappingURL=x-tokenName.js.map