@scalar/schemas 0.2.0 → 0.3.0

package/dist/extensions/example/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/example/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA"}

package/dist/extensions/example/index.js

@@ -0,0 +1,6 @@
+/**
+ * Example Scalar extensions.
+ *
+ * Applied on OpenAPI examples (parameter examples, request body examples, etc.).
+ */
+export { XDisabled } from './x-disabled.js';

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

@@ -0,0 +1,17 @@
+/**
+ * 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
+ * ```
+ */
+export declare const XDisabled: import("@scalar/validation").ObjectSchema<{
+    'x-disabled': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>;
+//# sourceMappingURL=x-disabled.d.ts.map

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

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

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

@@ -0,0 +1,23 @@
+import { boolean, object, optional } from '@scalar/validation';
+import { typeCommentInlineCode, typeCommentWithExample } from '../type-comment.js';
+/**
+ * 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
+ * ```
+ */
+export const XDisabled = object({
+    'x-disabled': optional(boolean({
+        typeComment: 'When true, the parameter example is not sent with the request',
+    })),
+}, {
+    typeName: 'XDisabled',
+    typeComment: typeCommentWithExample(`Whether a parameter example is disabled in the API client (${typeCommentInlineCode('true')} = not sent).`, { language: 'yaml', body: 'x-disabled: true' }),
+});

package/dist/extensions/general/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * General Scalar extensions.
+ *
+ * May appear on multiple OpenAPI object types (operations, parameters, etc.). Includes request/response
+ * scripts, workspace cookies, environment selection, and custom ordering.
+ */
+export { XPostResponse } from './x-post-response.js';
+export { XPreRequest } from './x-pre-request.js';
+export { XScalarActiveEnvironment } from './x-scalar-active-environment.js';
+export { XScalarCookie, XScalarCookies } from './x-scalar-cookies.js';
+export { XScalarOrder } from './x-scalar-order.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/general/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/general/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/extensions/general/index.js

@@ -0,0 +1,11 @@
+/**
+ * General Scalar extensions.
+ *
+ * May appear on multiple OpenAPI object types (operations, parameters, etc.). Includes request/response
+ * scripts, workspace cookies, environment selection, and custom ordering.
+ */
+export { XPostResponse } from './x-post-response.js';
+export { XPreRequest } from './x-pre-request.js';
+export { XScalarActiveEnvironment } from './x-scalar-active-environment.js';
+export { XScalarCookie, XScalarCookies } from './x-scalar-cookies.js';
+export { XScalarOrder } from './x-scalar-order.js';

package/dist/extensions/general/x-post-response.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Post response scripts allow to execute arbitrary code after a response is received.
+ *
+ * This is useful for:
+ * - Extracting data from the response, or
+ * - Testing the response
+ *
+ * @example
+ * ```yaml
+ * x-post-response: |
+ *   pm.test("Status code is 200", () => {
+ *     pm.response.to.have.status(200)
+ *   })
+ * ```
+ */
+export declare const 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/extensions/general/x-post-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-post-response.d.ts","sourceRoot":"","sources":["../../../src/extensions/general/x-post-response.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa;;EAqBzB,CAAA"}

package/dist/extensions/general/x-post-response.js

@@ -0,0 +1,31 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * 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 XPostResponse = object({
+    'x-post-response': optional(string({
+        typeComment: 'Script executed after a response is received',
+    })),
+}, {
+    typeName: 'XPostResponse',
+    typeComment: typeCommentWithExample('Post-response script for an operation. Use to extract response data or assert on the response.', {
+        language: 'yaml',
+        body: `x-post-response: |
+  pm.test("Status code is 200", () => {
+    pm.response.to.have.status(200)
+  })`,
+    }),
+});

package/dist/extensions/general/x-pre-request.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pre-request scripts run before a request is sent. They are used to prepare or modify anything needed for the request to succeed.
+ *
+ * Common uses:
+ * - Set up data and variables
+ * - Generate timestamps, random values, IDs, or nonces
+ * - Set environment or collection variables for use in the URL, headers, or body
+ *
+ * @example
+ * ```yaml
+ * x-pre-request: |
+ *   var token = pm.environment.get("token")
+ *   pm.request.headers.set("Authorization", `Bearer ${token}`)
+ * ```
+ */
+export declare const XPreRequest: import("@scalar/validation").ObjectSchema<{
+    'x-pre-request': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=x-pre-request.d.ts.map

package/dist/extensions/general/x-pre-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-pre-request.d.ts","sourceRoot":"","sources":["../../../src/extensions/general/x-pre-request.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;EAoBvB,CAAA"}

package/dist/extensions/general/x-pre-request.js

@@ -0,0 +1,30 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * Pre-request scripts run before a request is sent. They are used to prepare or modify anything needed for the request to succeed.
+ *
+ * Common uses:
+ * - Set up data and variables
+ * - Generate timestamps, random values, IDs, or nonces
+ * - Set environment or collection variables for use in the URL, headers, or body
+ *
+ * @example
+ * ```yaml
+ * x-pre-request: |
+ *   var token = pm.environment.get("token")
+ *   pm.request.headers.set("Authorization", `Bearer ${token}`)
+ * ```
+ */
+export const XPreRequest = object({
+    'x-pre-request': optional(string({
+        typeComment: 'Script executed before the request is sent',
+    })),
+}, {
+    typeName: 'XPreRequest',
+    typeComment: typeCommentWithExample('Pre-request script to run before the request is sent. Use to set variables, generate values, or modify headers.', {
+        language: 'yaml',
+        body: `x-pre-request: |
+  var token = pm.environment.get("token")
+  pm.request.headers.set("Authorization", \`Bearer \${token}\`)`,
+    }),
+});

package/dist/extensions/general/x-scalar-active-environment.d.ts

@@ -0,0 +1,5 @@
+/** The currently selected environment for this API description */
+export declare const XScalarActiveEnvironment: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-active-environment': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=x-scalar-active-environment.d.ts.map

package/dist/extensions/general/x-scalar-active-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-active-environment.d.ts","sourceRoot":"","sources":["../../../src/extensions/general/x-scalar-active-environment.ts"],"names":[],"mappings":"AAIA,kEAAkE;AAClE,eAAO,MAAM,wBAAwB;;EAWpC,CAAA"}

package/dist/extensions/general/x-scalar-active-environment.js

@@ -0,0 +1,12 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/** The currently selected environment for this API description */
+export const XScalarActiveEnvironment = object({
+    'x-scalar-active-environment': optional(string({ typeComment: 'The currently selected environment name' })),
+}, {
+    typeName: 'XScalarActiveEnvironment',
+    typeComment: typeCommentWithExample('The currently selected environment for this API description.', {
+        language: 'yaml',
+        body: 'x-scalar-active-environment: production',
+    }),
+});

package/dist/extensions/general/x-scalar-cookies.d.ts

@@ -0,0 +1,17 @@
+export declare const XScalarCookie: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    value: import("@scalar/validation").StringSchema;
+    domain: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    path: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    isDisabled: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>;
+export declare const XScalarCookies: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-cookies': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        value: import("@scalar/validation").StringSchema;
+        domain: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        path: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        isDisabled: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>>;
+}>;
+//# sourceMappingURL=x-scalar-cookies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-cookies.d.ts","sourceRoot":"","sources":["../../../src/extensions/general/x-scalar-cookies.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;;;;;EAYzB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;EAkB1B,CAAA"}

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

@@ -0,0 +1,26 @@
+import { array, boolean, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarCookie = object({
+    name: string({ typeComment: 'Cookie name' }),
+    value: string({ typeComment: 'Cookie value' }),
+    domain: optional(string({ typeComment: 'Domain scope (includes subdomains when set)' })),
+    path: optional(string({ typeComment: 'Path scope — cookie is sent only for requests matching this path' })),
+    isDisabled: optional(boolean({ typeComment: 'When true, the cookie is not sent with requests' })),
+}, {
+    typeName: 'XScalarCookie',
+    typeComment: 'A persisted cookie definition for the workspace',
+});
+export const XScalarCookies = object({
+    'x-scalar-cookies': optional(array(XScalarCookie, {
+        typeComment: 'Cookies persisted for the workspace and injected into requests',
+    })),
+}, {
+    typeName: 'XScalarCookies',
+    typeComment: typeCommentWithExample('Persisted workspace cookies shared across requests.', {
+        language: 'yaml',
+        body: `x-scalar-cookies:
+  - name: session
+    value: abc123
+    path: /`,
+    }),
+});

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

@@ -0,0 +1,4 @@
+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/extensions/general/x-scalar-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-order.d.ts","sourceRoot":"","sources":["../../../src/extensions/general/x-scalar-order.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;EAqBxB,CAAA"}

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

@@ -0,0 +1,16 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarOrder = object({
+    'x-scalar-order': optional(array(string(), {
+        typeComment: 'Ordered list of element identifiers (tags, operations, etc.)',
+    })),
+}, {
+    typeName: 'XScalarOrder',
+    typeComment: typeCommentWithExample('Custom display order for elements in the Scalar UI (tags, operations, tag groups).', {
+        language: 'yaml',
+        body: `x-scalar-order:
+  - users
+  - pets
+  - admin`,
+    }),
+});

package/dist/extensions/operation/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Operation-level Scalar extensions.
+ *
+ * Applied on OpenAPI `paths` operations. Covers UI badges, code samples, stability, scripts,
+ * and client state such as selected content types and disabled parameters.
+ */
+export { XBadge, XBadges } from './x-badge.js';
+export { XCodeSample, XCodeSamples } from './x-code-samples.js';
+export { XDraftExamples } from './x-draft-examples.js';
+export { XScalarDisableParameters } from './x-scalar-disable-parameters.js';
+export { XScalarSelectedContentType } from './x-scalar-selected-content-type.js';
+export { XScalarStability, XScalarStabilityValues } from './x-scalar-stability.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/operation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AAC7E,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/extensions/operation/index.js

@@ -0,0 +1,12 @@
+/**
+ * Operation-level Scalar extensions.
+ *
+ * Applied on OpenAPI `paths` operations. Covers UI badges, code samples, stability, scripts,
+ * and client state such as selected content types and disabled parameters.
+ */
+export { XBadge, XBadges } from './x-badge.js';
+export { XCodeSample, XCodeSamples } from './x-code-samples.js';
+export { XDraftExamples } from './x-draft-examples.js';
+export { XScalarDisableParameters } from './x-scalar-disable-parameters.js';
+export { XScalarSelectedContentType } from './x-scalar-selected-content-type.js';
+export { XScalarStability, XScalarStabilityValues } from './x-scalar-stability.js';

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

@@ -0,0 +1,38 @@
+/**
+ * Schema for individual badge configuration in the x-badges extension.
+ * Badges are indicators that can be displayed in API documentation.
+ */
+export declare const XBadge: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    position: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"before">, import("@scalar/validation").LiteralSchema<"after">]>>;
+    color: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+/**
+ * Badges for an operation in the Scalar UI.
+ *
+ * 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.
+ *
+ * @example
+ * ```yaml
+ * paths:
+ *   /hello-world:
+ *     get:
+ *       summary: Hello World
+ *       x-badges:
+ *         - name: Alpha
+ *         - name: Beta
+ *           position: before
+ *         - name: Gamma
+ *           position: after
+ *           color: "#ffcc00"
+ * ```
+ */
+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<readonly [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/extensions/operation/x-badge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-badge.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-badge.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;EAyBlB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,OAAO;;;;;;EAqBnB,CAAA"}

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

@@ -0,0 +1,60 @@
+import { array, literal, object, optional, string, union } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * Schema for individual badge configuration in the x-badges extension.
+ * Badges are indicators that can be displayed in API documentation.
+ */
+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. Defaults to `after` when omitted.',
+    })),
+    color: optional(string({
+        typeComment: 'The color of the badge in various formats (keywords, RGB, RGBA, HSL, HSLA, Hexadecimal)',
+    })),
+}, {
+    typeName: 'XBadge',
+    typeComment: typeCommentWithExample('Configuration for a single badge in the x-badges extension.', {
+        language: 'yaml',
+        body: `name: Beta
+position: before
+color: "#ffcc00"`,
+    }),
+});
+/**
+ * Badges for an operation in the Scalar UI.
+ *
+ * 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.
+ *
+ * @example
+ * ```yaml
+ * paths:
+ *   /hello-world:
+ *     get:
+ *       summary: Hello World
+ *       x-badges:
+ *         - name: Alpha
+ *         - name: Beta
+ *           position: before
+ *         - name: Gamma
+ *           position: after
+ *           color: "#ffcc00"
+ * ```
+ */
+export const XBadges = object({
+    'x-badges': optional(array(XBadge, {
+        typeComment: 'Badges displayed for this operation in documentation',
+    })),
+}, {
+    typeName: 'XBadges',
+    typeComment: typeCommentWithExample('Badges for an operation in the Scalar UI. Use as visual indicators in documentation.', {
+        language: 'yaml',
+        body: `x-badges:
+  - name: Alpha
+  - name: Beta
+    position: before`,
+    }),
+});

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

@@ -0,0 +1,23 @@
+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 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/extensions/operation/x-code-samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-code-samples.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-code-samples.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;EAUvB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAmBxB,CAAA"}

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

@@ -0,0 +1,24 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { typeCommentInlineCode, typeCommentWithExample } from '../type-comment.js';
+export const XCodeSample = object({
+    lang: optional(string({ typeComment: 'Programming language for syntax highlighting' })),
+    label: optional(string({ typeComment: 'Label shown in the code sample picker' })),
+    source: string({ typeComment: 'Source code for the sample' }),
+}, {
+    typeName: 'XCodeSample',
+    typeComment: 'A single code sample for documentation or examples',
+});
+export const XCodeSamples = object({
+    'x-codeSamples': optional(array(XCodeSample, { typeComment: 'Code samples (camelCase spelling)' })),
+    'x-code-samples': optional(array(XCodeSample, { typeComment: 'Code samples (kebab-case spelling)' })),
+    'x-custom-examples': optional(array(XCodeSample, { typeComment: 'Custom code examples for the operation' })),
+}, {
+    typeName: 'XCodeSamples',
+    typeComment: typeCommentWithExample(`Code samples attached to an operation. Supports ${typeCommentInlineCode('x-codeSamples')}, ${typeCommentInlineCode('x-code-samples')}, and ${typeCommentInlineCode('x-custom-examples')}.`, {
+        language: 'yaml',
+        body: `x-code-samples:
+  - lang: curl
+    label: cURL
+    source: curl https://api.example.com`,
+    }),
+});

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

@@ -0,0 +1,4 @@
+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/extensions/operation/x-draft-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-draft-examples.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-draft-examples.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;EAoB1B,CAAA"}

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

@@ -0,0 +1,15 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XDraftExamples = object({
+    'x-draft-examples': optional(array(string(), {
+        typeComment: 'Identifiers of draft examples attached to this operation',
+    })),
+}, {
+    typeName: 'XDraftExamples',
+    typeComment: typeCommentWithExample('Draft example identifiers for an operation (in-progress examples not yet committed).', {
+        language: 'yaml',
+        body: `x-draft-examples:
+  - default
+  - error-case`,
+    }),
+});

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

@@ -0,0 +1,8 @@
+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>>>;
+    }>>;
+}>;
+//# sourceMappingURL=x-scalar-disable-parameters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-disable-parameters.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-scalar-disable-parameters.ts"],"names":[],"mappings":"AAoEA,eAAO,MAAM,wBAAwB;;;;;;EAuBpC,CAAA"}

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

@@ -0,0 +1,74 @@
+import { boolean, object, optional, record, string } from '@scalar/validation';
+import { typeCommentExample, typeCommentSections } from '../type-comment.js';
+/**
+ * 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
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+const ExampleParameterState = record(string(), boolean());
+const ExamplesParameterStates = record(string(), ExampleParameterState);
+const DisableParametersInner = object({
+    'global-cookies': optional(ExamplesParameterStates, {
+        typeComment: 'Disabled state for global cookie parameters across examples',
+    }),
+    'global-headers': optional(ExamplesParameterStates, {
+        typeComment: 'Disabled state for global header parameters across examples',
+    }),
+    'default-headers': optional(ExamplesParameterStates, {
+        typeComment: 'Disabled state for default header parameters across examples',
+    }),
+}, {
+    typeName: 'DisableParametersConfig',
+    typeComment: 'Disabled parameter state by category and example',
+});
+export const XScalarDisableParameters = object({
+    'x-scalar-disable-parameters': optional(DisableParametersInner, {
+        typeComment: 'Disabled parameter state organized by category, example, and parameter name',
+    }),
+}, {
+    typeName: 'XScalarDisableParameters',
+    typeComment: typeCommentSections('Tracks which parameters are disabled across examples in the API client.', 'Structure: category (global-cookies, global-headers, default-headers) → example key → parameter name → true if disabled.', typeCommentExample('json', `{
+  "x-scalar-disable-parameters": {
+    "default-headers": {
+      "default": { "Content-Type": true, "Accept": false }
+    }
+  }
+}`)),
+});

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

@@ -0,0 +1,10 @@
+/**
+ * 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 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/extensions/operation/x-scalar-selected-content-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-selected-content-type.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-scalar-selected-content-type.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;EAoBtC,CAAA"}