@scalar/schemas 0.2.0 → 0.3.1

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"}

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

@@ -0,0 +1,21 @@
+import { object, optional, record, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * 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 XScalarSelectedContentType = object({
+    'x-scalar-selected-content-type': optional(record(string(), string(), {
+        typeComment: 'Map of example name to selected content type (for example `application/json`)',
+    })),
+}, {
+    typeName: 'XScalarSelectedContentType',
+    typeComment: typeCommentWithExample('Selected content type per example for request or response bodies. Keys are example names; values are media types.', {
+        language: 'yaml',
+        body: `x-scalar-selected-content-type:
+  default: application/json
+  xml-example: application/xml`,
+    }),
+});

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

@@ -0,0 +1,9 @@
+export declare const XScalarStabilityValues: {
+    readonly Deprecated: "deprecated";
+    readonly Experimental: "experimental";
+    readonly Stable: "stable";
+};
+export declare const XScalarStability: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-stability': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"deprecated">, import("@scalar/validation").LiteralSchema<"experimental">, import("@scalar/validation").LiteralSchema<"stable">]>>;
+}>;
+//# sourceMappingURL=x-scalar-stability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-stability.d.ts","sourceRoot":"","sources":["../../../src/extensions/operation/x-scalar-stability.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAA;AAEV,eAAO,MAAM,gBAAgB;;EAe5B,CAAA"}

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

@@ -0,0 +1,18 @@
+import { literal, object, optional, union } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarStabilityValues = {
+    Deprecated: 'deprecated',
+    Experimental: 'experimental',
+    Stable: 'stable',
+};
+export const XScalarStability = object({
+    'x-scalar-stability': optional(union([literal('deprecated'), literal('experimental'), literal('stable')], {
+        typeComment: 'Stability level: `deprecated`, `experimental`, or `stable`',
+    })),
+}, {
+    typeName: 'XScalarStability',
+    typeComment: typeCommentWithExample('Indicates the stability of an operation in the Scalar UI.', {
+        language: 'yaml',
+        body: 'x-scalar-stability: deprecated',
+    }),
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Parameter Scalar extensions.
+ *
+ * Applied on OpenAPI parameters (path, query, header, cookie). Used by the API client for global
+ * parameter injection and example state.
+ */
+export { XGlobal } from './x-global.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/extensions/parameter/index.js

@@ -0,0 +1,7 @@
+/**
+ * Parameter Scalar extensions.
+ *
+ * Applied on OpenAPI parameters (path, query, header, cookie). Used by the API client for global
+ * parameter injection and example state.
+ */
+export { XGlobal } from './x-global.js';

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

@@ -0,0 +1,13 @@
+/**
+ * OpenAPI extension used by the API client to determine if a parameter is global in scope
+ * for the entire workspace. When set, this parameter is injected into every request automatically.
+ *
+ * @example
+ * ```yaml
+ * x-global: true
+ * ```
+ */
+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/extensions/parameter/x-global.d.ts.map

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

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

@@ -0,0 +1,22 @@
+import { boolean, object, optional } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * OpenAPI extension used by the API client to determine if a parameter is global in scope
+ * for the entire workspace. When set, this parameter is injected into every request automatically.
+ *
+ * @example
+ * ```yaml
+ * x-global: true
+ * ```
+ */
+export const XGlobal = object({
+    'x-global': optional(boolean({
+        typeComment: 'When true, the parameter is injected into every request for the workspace',
+    })),
+}, {
+    typeName: 'XGlobal',
+    typeComment: typeCommentWithExample('When true, the parameter is injected into every request for the workspace.', {
+        language: 'yaml',
+        body: 'x-global: true',
+    }),
+});

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

@@ -0,0 +1,12 @@
+/**
+ * JSON Schema Scalar extensions.
+ *
+ * Applied on OpenAPI `components.schemas` or inline schema objects. Covers enum metadata,
+ * examples, variables, and additional property naming.
+ */
+export { XAdditionalPropertiesName } from './x-additional-properties-name.js';
+export { XEnumDescriptions } from './x-enum-descriptions.js';
+export { XEnumVarNames } from './x-enum-varnames.js';
+export { XExamples } from './x-examples.js';
+export { XVariable } from './x-variable.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/schema/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA"}

package/dist/extensions/schema/index.js

@@ -0,0 +1,11 @@
+/**
+ * JSON Schema Scalar extensions.
+ *
+ * Applied on OpenAPI `components.schemas` or inline schema objects. Covers enum metadata,
+ * examples, variables, and additional property naming.
+ */
+export { XAdditionalPropertiesName } from './x-additional-properties-name.js';
+export { XEnumDescriptions } from './x-enum-descriptions.js';
+export { XEnumVarNames } from './x-enum-varnames.js';
+export { XExamples } from './x-examples.js';
+export { XVariable } from './x-variable.js';

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

@@ -0,0 +1,10 @@
+/**
+ * x-additionalPropertiesName
+ *
+ * Custom attribute name for additionalProperties in a schema.
+ * This allows specifying a descriptive name for additional properties that may be present in an object.
+ */
+export declare const 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/extensions/schema/x-additional-properties-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-additional-properties-name.d.ts","sourceRoot":"","sources":["../../../src/extensions/schema/x-additional-properties-name.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;EAerC,CAAA"}

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

@@ -0,0 +1,19 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * 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 XAdditionalPropertiesName = object({
+    'x-additionalPropertiesName': optional(string({
+        typeComment: 'Human-readable label for additional properties on this schema',
+    })),
+}, {
+    typeName: 'XAdditionalPropertiesName',
+    typeComment: typeCommentWithExample('Display name for additional properties on a schema object.', {
+        language: 'yaml',
+        body: 'x-additionalPropertiesName: metadata',
+    }),
+});

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

@@ -0,0 +1,20 @@
+/**
+ * x-enumDescriptions / x-enum-descriptions
+ *
+ * Maps enum values to their descriptions. Each key should correspond to an enum value,
+ * and the value is the description for that enum value.
+ *
+ * @example
+ * ```yaml
+ * x-enumDescriptions:
+ *   missing_features: Missing features
+ *   too_expensive: Too expensive
+ *   unused: Unused
+ *   other: Other
+ * ```
+ */
+export declare const XEnumDescriptions: import("@scalar/validation").ObjectSchema<{
+    'x-enumDescriptions': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [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<readonly [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/extensions/schema/x-enum-descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-enum-descriptions.d.ts","sourceRoot":"","sources":["../../../src/extensions/schema/x-enum-descriptions.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;EAiB7B,CAAA"}

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

@@ -0,0 +1,33 @@
+import { array, object, optional, record, string, union } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+const enumDescriptionValue = union([record(string(), string()), array(string())]);
+/**
+ * x-enumDescriptions / x-enum-descriptions
+ *
+ * Maps enum values to their descriptions. Each key should correspond to an enum value,
+ * and the value is the description for that enum value.
+ *
+ * @example
+ * ```yaml
+ * x-enumDescriptions:
+ *   missing_features: Missing features
+ *   too_expensive: Too expensive
+ *   unused: Unused
+ *   other: Other
+ * ```
+ */
+export const XEnumDescriptions = object({
+    'x-enumDescriptions': optional(enumDescriptionValue, {
+        typeComment: 'Map or list of descriptions keyed by enum value (camelCase spelling)',
+    }),
+    'x-enum-descriptions': optional(enumDescriptionValue, {
+        typeComment: 'Map or list of descriptions keyed by enum value (kebab-case spelling)',
+    }),
+}, {
+    typeName: 'XEnumDescriptions',
+    typeComment: typeCommentWithExample('Descriptions for enum values. Keys must match enum values.', {
+        language: 'yaml',
+        body: `x-enumDescriptions:
+  other: Other reason`,
+    }),
+});

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

@@ -0,0 +1,22 @@
+/**
+ * x-enum-varnames / x-enumNames
+ *
+ * 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 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/extensions/schema/x-enum-varnames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-enum-varnames.d.ts","sourceRoot":"","sources":["../../../src/extensions/schema/x-enum-varnames.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa;;;EAwBzB,CAAA"}

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

@@ -0,0 +1,34 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { typeCommentInlineCode, typeCommentWithExample } from '../type-comment.js';
+/**
+ * x-enum-varnames / x-enumNames
+ *
+ * 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 XEnumVarNames = object({
+    'x-enum-varnames': optional(array(string(), {
+        typeComment: 'Display names for enum values (same order as `enum`)',
+    })),
+    'x-enumNames': optional(array(string(), {
+        typeComment: 'Alias for x-enum-varnames — display names for enum values',
+    })),
+}, {
+    typeName: 'XEnumVarNames',
+    typeComment: typeCommentWithExample(`Display names for enum values. Must match the order of the ${typeCommentInlineCode('enum')} array.`, {
+        language: 'yaml',
+        body: `enum: [moon, asteroid]
+x-enum-varnames: [Moon, Asteroid]`,
+    }),
+});

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

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

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

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

@@ -0,0 +1,16 @@
+import { any, object, optional, record, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XExamples = object({
+    'x-examples': optional(record(string(), any(), {
+        typeComment: 'Map of example name to example value',
+    })),
+}, {
+    typeName: 'XExamples',
+    typeComment: typeCommentWithExample('Named examples attached to a schema. Keys are example names; values are the example payloads.', {
+        language: 'yaml',
+        body: `x-examples:
+  user:
+    id: 1
+    name: Ada`,
+    }),
+});

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

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

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

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

@@ -0,0 +1,11 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XVariable = object({
+    'x-variable': optional(string({ typeComment: 'Variable name used for substitution in the API client' })),
+}, {
+    typeName: 'XVariable',
+    typeComment: typeCommentWithExample('References a variable for schema property substitution in the API client.', {
+        language: 'yaml',
+        body: 'x-variable: userId',
+    }),
+});

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

@@ -0,0 +1,14 @@
+/**
+ * Security scheme Scalar extensions.
+ *
+ * Applied on OpenAPI `components.securitySchemes` entries. Configures OAuth2 behavior, credential
+ * placement, PKCE, default scopes, and persisted secrets (not exported with the document).
+ */
+export { XDefaultScopes } from './x-default-scopes.js';
+export { XScalarCredentialsLocation } from './x-scalar-credentials-location.js';
+export { XScalarSecurityBody } from './x-scalar-security-body.js';
+export { XScalarSecurityQuery } from './x-scalar-security-query.js';
+export { XScalarAuthUrl, XScalarSecretClientId, XScalarSecretClientSecret, XScalarSecretHTTP, XScalarSecretRedirectUri, XScalarSecretRefreshToken, XScalarSecretToken, XScalarTokenUrl, } from './x-scalar-security-secrets.js';
+export { XTokenName } from './x-tokenName.js';
+export { XusePkce } from './x-use-pkce.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/security/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAA;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,yBAAyB,EACzB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,kBAAkB,EAClB,eAAe,GAChB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA"}

package/dist/extensions/security/index.js

@@ -0,0 +1,13 @@
+/**
+ * Security scheme Scalar extensions.
+ *
+ * Applied on OpenAPI `components.securitySchemes` entries. Configures OAuth2 behavior, credential
+ * placement, PKCE, default scopes, and persisted secrets (not exported with the document).
+ */
+export { XDefaultScopes } from './x-default-scopes.js';
+export { XScalarCredentialsLocation } from './x-scalar-credentials-location.js';
+export { XScalarSecurityBody } from './x-scalar-security-body.js';
+export { XScalarSecurityQuery } from './x-scalar-security-query.js';
+export { XScalarAuthUrl, XScalarSecretClientId, XScalarSecretClientSecret, XScalarSecretHTTP, XScalarSecretRedirectUri, XScalarSecretRefreshToken, XScalarSecretToken, XScalarTokenUrl, } from './x-scalar-security-secrets.js';
+export { XTokenName } from './x-tokenName.js';
+export { XusePkce } from './x-use-pkce.js';

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

@@ -0,0 +1,14 @@
+/**
+ * Default selected scopes for the OAuth flow.
+ *
+ * @example
+ * ```json
+ * {
+ *   "x-default-scopes": ["profile", "email"]
+ * }
+ * ```
+ */
+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/extensions/security/x-default-scopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-default-scopes.d.ts","sourceRoot":"","sources":["../../../src/extensions/security/x-default-scopes.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;EAe1B,CAAA"}

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

@@ -0,0 +1,23 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * Default selected scopes for the OAuth flow.
+ *
+ * @example
+ * ```json
+ * {
+ *   "x-default-scopes": ["profile", "email"]
+ * }
+ * ```
+ */
+export const XDefaultScopes = object({
+    'x-default-scopes': optional(array(string(), {
+        typeComment: 'Scopes pre-selected in the OAuth consent UI',
+    })),
+}, {
+    typeName: 'XDefaultScopes',
+    typeComment: typeCommentWithExample('Default selected OAuth scopes.', {
+        language: 'json',
+        body: '{ "x-default-scopes": ["profile", "email"] }',
+    }),
+});

package/dist/extensions/security/x-scalar-credentials-location.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 declare const XScalarCredentialsLocation: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-credentials-location': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"header">, import("@scalar/validation").LiteralSchema<"body">]>>;
+}>;
+//# sourceMappingURL=x-scalar-credentials-location.d.ts.map

package/dist/extensions/security/x-scalar-credentials-location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-credentials-location.d.ts","sourceRoot":"","sources":["../../../src/extensions/security/x-scalar-credentials-location.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B;;EAetC,CAAA"}

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

@@ -0,0 +1,26 @@
+import { literal, object, optional, union } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * 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 XScalarCredentialsLocation = object({
+    'x-scalar-credentials-location': optional(union([literal('header'), literal('body')], {
+        typeComment: 'Where OAuth2 credentials are sent (`header` or `body`)',
+    })),
+}, {
+    typeName: 'XScalarCredentialsLocation',
+    typeComment: typeCommentWithExample('Where OAuth2 credentials are sent for this security scheme.', {
+        language: 'yaml',
+        body: 'x-scalar-credentials-location: header',
+    }),
+});

package/dist/extensions/security/x-scalar-security-body.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 declare const XScalarSecurityBody: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-security-body': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+}>;
+//# sourceMappingURL=x-scalar-security-body.d.ts.map

package/dist/extensions/security/x-scalar-security-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-security-body.d.ts","sourceRoot":"","sources":["../../../src/extensions/security/x-scalar-security-body.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB;;EAiB/B,CAAA"}

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

@@ -0,0 +1,25 @@
+import { object, optional, record, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * 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 XScalarSecurityBody = object({
+    'x-scalar-security-body': optional(record(string(), string(), {
+        typeComment: 'Additional body parameters for the OAuth token request',
+    })),
+}, {
+    typeName: 'XScalarSecurityBody',
+    typeComment: typeCommentWithExample('Additional OAuth token request body parameters.', {
+        language: 'yaml',
+        body: `x-scalar-security-body:
+  audience: https://api.example.com
+  resource: user-profile`,
+    }),
+});

package/dist/extensions/security/x-scalar-security-query.d.ts

@@ -0,0 +1,14 @@
+/**
+ * An OpenAPI extension to set any query parameters for the OAuth authorize request.
+ *
+ * @example
+ * ```yaml
+ * x-scalar-security-query:
+ *   prompt: consent
+ *   audience: scalar
+ * ```
+ */
+export declare const XScalarSecurityQuery: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-security-query': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+}>;
+//# sourceMappingURL=x-scalar-security-query.d.ts.map