@scalar/schemas 0.2.0 → 0.3.0

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

@@ -0,0 +1,57 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarSecretToken = object({
+    'x-scalar-secret-token': string({
+        typeComment: 'Persisted OAuth access token',
+    }),
+}, {
+    typeName: 'XScalarSecretToken',
+    typeComment: typeCommentWithExample('Persisted OAuth access token (sensitive). Do not export when exporting the document.', { language: 'yaml', body: 'x-scalar-secret-token: eyJhbG...' }),
+});
+export const XScalarSecretRefreshToken = object({
+    'x-scalar-secret-refresh-token': optional(string({ typeComment: 'Persisted OAuth refresh token' })),
+}, {
+    typeName: 'XScalarSecretRefreshToken',
+    typeComment: 'Persisted OAuth refresh token (sensitive). Do not export when exporting the document.',
+});
+export const XScalarAuthUrl = object({
+    'x-scalar-secret-auth-url': optional(string({ typeComment: 'Override for the OAuth authorization endpoint URL' })),
+}, {
+    typeName: 'XScalarAuthUrl',
+    typeComment: 'Persisted OAuth authorization URL override. Do not export when exporting the document.',
+});
+export const XScalarTokenUrl = object({
+    'x-scalar-secret-token-url': optional(string({ typeComment: 'Override for the OAuth token endpoint URL' })),
+}, {
+    typeName: 'XScalarTokenUrl',
+    typeComment: 'Persisted OAuth token URL override. Do not export when exporting the document.',
+});
+export const XScalarSecretHTTP = object({
+    'x-scalar-secret-username': string({ typeComment: 'HTTP basic auth username' }),
+    'x-scalar-secret-password': string({ typeComment: 'HTTP basic auth password' }),
+}, {
+    typeName: 'XScalarSecretHTTP',
+    typeComment: typeCommentWithExample('Persisted HTTP basic credentials (sensitive). Do not export when exporting the document.', {
+        language: 'yaml',
+        body: `x-scalar-secret-username: api-user
+x-scalar-secret-password: secret`,
+    }),
+});
+export const XScalarSecretClientSecret = object({
+    'x-scalar-secret-client-secret': string({ typeComment: 'OAuth client secret' }),
+}, {
+    typeName: 'XScalarSecretClientSecret',
+    typeComment: 'Persisted OAuth client secret (sensitive). Do not export when exporting the document.',
+});
+export const XScalarSecretClientId = object({
+    'x-scalar-secret-client-id': string({ typeComment: 'OAuth client ID' }),
+}, {
+    typeName: 'XScalarSecretClientId',
+    typeComment: 'Persisted OAuth client ID. Do not export when exporting the document.',
+});
+export const XScalarSecretRedirectUri = object({
+    'x-scalar-secret-redirect-uri': string({ typeComment: 'OAuth redirect URI registered for this client' }),
+}, {
+    typeName: 'XScalarSecretRedirectUri',
+    typeComment: 'Persisted OAuth redirect URI. Do not export when exporting the document.',
+});

package/dist/extensions/security/x-tokenName.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An OpenAPI extension to specify a custom token name for OAuth2 flows.
+ *
+ * @example
+ * ```yaml
+ * x-tokenName: custom_access_token
+ * ```
+ */
+export declare const XTokenName: import("@scalar/validation").ObjectSchema<{
+    'x-tokenName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=x-tokenName.d.ts.map

package/dist/extensions/security/x-tokenName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-tokenName.d.ts","sourceRoot":"","sources":["../../../src/extensions/security/x-tokenName.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;EAetB,CAAA"}

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

@@ -0,0 +1,21 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * An OpenAPI extension to specify a custom token name for OAuth2 flows.
+ *
+ * @example
+ * ```yaml
+ * x-tokenName: custom_access_token
+ * ```
+ */
+export const XTokenName = object({
+    'x-tokenName': optional(string({
+        typeComment: 'Custom field name for the OAuth2 access token in responses',
+    })),
+}, {
+    typeName: 'XTokenName',
+    typeComment: typeCommentWithExample('Custom OAuth2 access token field name.', {
+        language: 'yaml',
+        body: 'x-tokenName: custom_access_token',
+    }),
+});

package/dist/extensions/security/x-use-pkce.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Use `x-usePkce` to enable Proof Key for Code Exchange (PKCE) for the OAuth2 authorization code flow.
+ */
+export declare const XusePkce: import("@scalar/validation").ObjectSchema<{
+    'x-usePkce': import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"no">, import("@scalar/validation").LiteralSchema<"SHA-256">, import("@scalar/validation").LiteralSchema<"plain">]>;
+}>;
+//# sourceMappingURL=x-use-pkce.d.ts.map

package/dist/extensions/security/x-use-pkce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-use-pkce.d.ts","sourceRoot":"","sources":["../../../src/extensions/security/x-use-pkce.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,QAAQ;;EAapB,CAAA"}

package/dist/extensions/security/x-use-pkce.js

@@ -0,0 +1,13 @@
+import { literal, object, union } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * Use `x-usePkce` to enable Proof Key for Code Exchange (PKCE) for the OAuth2 authorization code flow.
+ */
+export const XusePkce = object({
+    'x-usePkce': union([literal('no'), literal('SHA-256'), literal('plain')], {
+        typeComment: 'PKCE mode: `SHA-256`, `plain`, or `no` (disabled)',
+    }),
+}, {
+    typeName: 'XusePkce',
+    typeComment: typeCommentWithExample('Enables Proof Key for Code Exchange (PKCE) for the OAuth2 authorization code flow.', { language: 'yaml', body: 'x-usePkce: SHA-256' }),
+});

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

@@ -0,0 +1,7 @@
+/**
+ * Server Scalar extensions.
+ *
+ * Applied on OpenAPI `servers` entries or document-level server selection state.
+ */
+export { XScalarSelectedServer } from './x-scalar-selected-server.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/extensions/server/index.js

@@ -0,0 +1,6 @@
+/**
+ * Server Scalar extensions.
+ *
+ * Applied on OpenAPI `servers` entries or document-level server selection state.
+ */
+export { XScalarSelectedServer } from './x-scalar-selected-server.js';

package/dist/extensions/server/x-scalar-selected-server.d.ts

@@ -0,0 +1,4 @@
+export declare const XScalarSelectedServer: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-selected-server': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=x-scalar-selected-server.d.ts.map

package/dist/extensions/server/x-scalar-selected-server.d.ts.map

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

package/dist/extensions/server/x-scalar-selected-server.js

@@ -0,0 +1,11 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarSelectedServer = object({
+    'x-scalar-selected-server': optional(string({ typeComment: 'The URL of the currently selected server' })),
+}, {
+    typeName: 'XScalarSelectedServer',
+    typeComment: typeCommentWithExample('The URL of the currently selected server for this API description.', {
+        language: 'yaml',
+        body: 'x-scalar-selected-server: https://api.example.com',
+    }),
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Tag Scalar extensions.
+ *
+ * Applied on OpenAPI `tags` or tag group definitions. Controls display names, grouping, and ordering.
+ */
+export { XDisplayName } from './x-display-name.js';
+export { XTagGroup, XTagGroups } from './x-tag-groups.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/tag/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/extensions/tag/index.js

@@ -0,0 +1,7 @@
+/**
+ * Tag Scalar extensions.
+ *
+ * Applied on OpenAPI `tags` or tag group definitions. Controls display names, grouping, and ordering.
+ */
+export { XDisplayName } from './x-display-name.js';
+export { XTagGroup, XTagGroups } from './x-tag-groups.js';

package/dist/extensions/tag/x-display-name.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An OpenAPI extension to overwrite tag names with a display-friendly version.
+ *
+ * @example
+ * ```yaml
+ * x-displayName: planets
+ * ```
+ */
+export declare const XDisplayName: import("@scalar/validation").ObjectSchema<{
+    'x-displayName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=x-display-name.d.ts.map

package/dist/extensions/tag/x-display-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-display-name.d.ts","sourceRoot":"","sources":["../../../src/extensions/tag/x-display-name.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;EAexB,CAAA"}

package/dist/extensions/tag/x-display-name.js

@@ -0,0 +1,21 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * An OpenAPI extension to overwrite tag names with a display-friendly version.
+ *
+ * @example
+ * ```yaml
+ * x-displayName: planets
+ * ```
+ */
+export const XDisplayName = object({
+    'x-displayName': optional(string({
+        typeComment: 'Display-friendly name shown in the UI instead of the tag name',
+    })),
+}, {
+    typeName: 'XDisplayName',
+    typeComment: typeCommentWithExample('Display-friendly name for a tag.', {
+        language: 'yaml',
+        body: 'x-displayName: planets',
+    }),
+});

package/dist/extensions/tag/x-tag-groups.d.ts

@@ -0,0 +1,20 @@
+export declare const XTagGroup: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    tags: import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>]>;
+/**
+ * x-tagGroups
+ *
+ * List of tags to include in this group.
+ */
+export declare const XTagGroups: import("@scalar/validation").ObjectSchema<{
+    'x-tagGroups': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        tags: import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    }>]>>>;
+}>;
+//# sourceMappingURL=x-tag-groups.d.ts.map

package/dist/extensions/tag/x-tag-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-tag-groups.d.ts","sourceRoot":"","sources":["../../../src/extensions/tag/x-tag-groups.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;;;IAiBrB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;EAiBtB,CAAA"}

package/dist/extensions/tag/x-tag-groups.js

@@ -0,0 +1,33 @@
+import { array, intersection, object, optional, string } from '@scalar/validation';
+import { XScalarOrder as XScalarOrderFields } from '../general/x-scalar-order.js';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XTagGroup = intersection([
+    object({
+        name: string({ typeComment: 'The group name.' }),
+        tags: array(string(), { typeComment: 'List of tags to include in this group.' }),
+    }, {
+        typeName: 'XTagGroupBase',
+    }),
+    XScalarOrderFields,
+], {
+    typeName: 'XTagGroup',
+    typeComment: 'A tag group with optional custom ordering',
+});
+/**
+ * x-tagGroups
+ *
+ * List of tags to include in this group.
+ */
+export const XTagGroups = object({
+    'x-tagGroups': optional(array(XTagGroup, {
+        typeComment: 'Tag groups for organizing tags in the UI',
+    })),
+}, {
+    typeName: 'XTagGroups',
+    typeComment: typeCommentWithExample('Groups of tags for organizing the sidebar in the Scalar UI.', {
+        language: 'yaml',
+        body: `x-tagGroups:
+  - name: Core API
+    tags: [users, auth]`,
+    }),
+});

package/dist/extensions/type-comment.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Fenced code block for typeComment strings (used by type generation for JSDoc).
+ * Example bodies are passed through as-is so backticks and `${...}` appear literally in docs.
+ */
+export declare const typeCommentCodeBlock: (language: string, body: string) => string;
+/** `@example` section with a fenced code block for typeComment. */
+export declare const typeCommentExample: (language: string, body: string) => string;
+/** Inline code span for typeComment strings (for example `` `enum` ``). */
+export declare const typeCommentInlineCode: (text: string) => string;
+/** Join typeComment sections with a blank line between each. */
+export declare const typeCommentSections: (...sections: string[]) => string;
+/** Description plus an `@example` fenced code block for typeComment. */
+export declare const typeCommentWithExample: (description: string, example: {
+    language: string;
+    body: string;
+}) => string;
+//# sourceMappingURL=type-comment.d.ts.map

package/dist/extensions/type-comment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-comment.d.ts","sourceRoot":"","sources":["../../src/extensions/type-comment.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,EAAE,MAAM,MAAM,KAAG,MACQ,CAAA;AAE9E,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,EAAE,MAAM,MAAM,KAAG,MACf,CAAA;AAErD,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,GAAI,MAAM,MAAM,KAAG,MAAuB,CAAA;AAE5E,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,GAAI,GAAG,UAAU,MAAM,EAAE,KAAG,MAA+B,CAAA;AAE3F,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM,EAAE,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KAAG,MACpB,CAAA"}

package/dist/extensions/type-comment.js

@@ -0,0 +1,14 @@
+const TYPE_COMMENT_FENCE = '```';
+/**
+ * Fenced code block for typeComment strings (used by type generation for JSDoc).
+ * Example bodies are passed through as-is so backticks and `${...}` appear literally in docs.
+ */
+export const typeCommentCodeBlock = (language, body) => `${TYPE_COMMENT_FENCE}${language}\n${body.trimEnd()}\n${TYPE_COMMENT_FENCE}`;
+/** `@example` section with a fenced code block for typeComment. */
+export const typeCommentExample = (language, body) => `@example\n${typeCommentCodeBlock(language, body)}`;
+/** Inline code span for typeComment strings (for example `` `enum` ``). */
+export const typeCommentInlineCode = (text) => `\`${text}\``;
+/** Join typeComment sections with a blank line between each. */
+export const typeCommentSections = (...sections) => sections.join('\n\n');
+/** Description plus an `@example` fenced code block for typeComment. */
+export const typeCommentWithExample = (description, example) => typeCommentSections(description, typeCommentExample(example.language, example.body));

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

@@ -0,0 +1,9 @@
+/**
+ * Workspace Scalar extensions.
+ *
+ * Applied on workspace configuration, not on individual OpenAPI documents. Persists UI state such
+ * as tabs, proxies, and layout preferences.
+ */
+export { XScalarActiveProxy } from './x-scalar-active-proxy.js';
+export { Tab, XScalarTabs } from './x-scalar-tabs.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/workspace/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/extensions/workspace/index.js

@@ -0,0 +1,8 @@
+/**
+ * Workspace Scalar extensions.
+ *
+ * Applied on workspace configuration, not on individual OpenAPI documents. Persists UI state such
+ * as tabs, proxies, and layout preferences.
+ */
+export { XScalarActiveProxy } from './x-scalar-active-proxy.js';
+export { Tab, XScalarTabs } from './x-scalar-tabs.js';

package/dist/extensions/workspace/x-scalar-active-proxy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Schema for the x-scalar-active-proxy extension.
+ *
+ * This property indicates the currently selected proxy identifier.
+ *
+ * @example
+ * ```json
+ * { "x-scalar-active-proxy": "my-proxy-id" }
+ * ```
+ */
+export declare const XScalarActiveProxy: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-active-proxy': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").StringSchema, import("@scalar/validation").NullableSchema]>>;
+}>;
+//# sourceMappingURL=x-scalar-active-proxy.d.ts.map

package/dist/extensions/workspace/x-scalar-active-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-active-proxy.d.ts","sourceRoot":"","sources":["../../../src/extensions/workspace/x-scalar-active-proxy.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;EAe9B,CAAA"}

package/dist/extensions/workspace/x-scalar-active-proxy.js

@@ -0,0 +1,23 @@
+import { nullable, object, optional, string, union } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/**
+ * Schema for the x-scalar-active-proxy extension.
+ *
+ * This property indicates the currently selected proxy identifier.
+ *
+ * @example
+ * ```json
+ * { "x-scalar-active-proxy": "my-proxy-id" }
+ * ```
+ */
+export const XScalarActiveProxy = object({
+    'x-scalar-active-proxy': optional(union([string(), nullable()], {
+        typeComment: 'The currently selected proxy identifier, or null when none is selected',
+    })),
+}, {
+    typeName: 'XScalarActiveProxy',
+    typeComment: typeCommentWithExample('The currently selected proxy identifier for the workspace.', {
+        language: 'json',
+        body: '{ "x-scalar-active-proxy": "my-proxy-id" }',
+    }),
+});

package/dist/extensions/workspace/x-scalar-tabs.d.ts

@@ -0,0 +1,20 @@
+export declare const Tab: import("@scalar/validation").ObjectSchema<{
+    path: import("@scalar/validation").StringSchema;
+    title: import("@scalar/validation").StringSchema;
+    icon: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+/**
+ * Schema for workspace tab configuration.
+ *
+ * This extension allows storing the list of open tabs and which tab is currently active.
+ * Useful for preserving the user workspace state across sessions.
+ */
+export declare const XScalarTabs: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-tabs': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        path: import("@scalar/validation").StringSchema;
+        title: import("@scalar/validation").StringSchema;
+        icon: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>>;
+    'x-scalar-active-tab': import("@scalar/validation").OptionalSchema<import("@scalar/validation").NumberSchema>;
+}>;
+//# sourceMappingURL=x-scalar-tabs.d.ts.map

package/dist/extensions/workspace/x-scalar-tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-tabs.d.ts","sourceRoot":"","sources":["../../../src/extensions/workspace/x-scalar-tabs.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,GAAG;;;;EAUf,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;EA0BvB,CAAA"}

package/dist/extensions/workspace/x-scalar-tabs.js

@@ -0,0 +1,33 @@
+import { array, number, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const Tab = object({
+    path: string({ typeComment: 'Tab path or document identifier' }),
+    title: string({ typeComment: 'Tab title shown in the UI' }),
+    icon: optional(string({ typeComment: 'Tab icon (`request` or `document`)' })),
+}, {
+    typeName: 'Tab',
+    typeComment: 'An open tab in the workspace',
+});
+/**
+ * Schema for workspace tab configuration.
+ *
+ * This extension allows storing the list of open tabs and which tab is currently active.
+ * Useful for preserving the user workspace state across sessions.
+ */
+export const XScalarTabs = object({
+    'x-scalar-tabs': optional(array(Tab, {
+        typeComment: 'Tabs that are open in the workspace',
+    })),
+    'x-scalar-active-tab': optional(number({
+        typeComment: 'Index of the currently active or focused tab',
+    })),
+}, {
+    typeName: 'XScalarTabs',
+    typeComment: typeCommentWithExample('Workspace tab configuration. Persists open tabs and the active tab across sessions.', {
+        language: 'yaml',
+        body: `x-scalar-tabs:
+  - path: /users
+    title: Users
+x-scalar-active-tab: 0`,
+    }),
+});

package/dist/general/bundler-extensions.d.ts

@@ -0,0 +1,5 @@
+export declare const referenceExtensions: import("@scalar/validation").ObjectSchema<{
+    $status: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"loading">, import("@scalar/validation").LiteralSchema<"error">]>>;
+    $global: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>;
+//# sourceMappingURL=bundler-extensions.d.ts.map

package/dist/general/bundler-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundler-extensions.d.ts","sourceRoot":"","sources":["../../src/general/bundler-extensions.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;EAa/B,CAAA"}

package/dist/general/bundler-extensions.js

@@ -0,0 +1,9 @@
+import { boolean, literal, object, optional, union } from '@scalar/validation';
+export const referenceExtensions = object({
+    '$status': optional(union([literal('loading'), literal('error')]), {
+        typeComment: `Indicates the current status of the reference resolution. Can be either 'loading' while fetching the reference or 'error' if the resolution failed.`,
+    }),
+    '$global': optional(boolean({
+        typeComment: 'Indicates whether this reference should be resolved globally across all documents, rather than just within the current document context.',
+    })),
+}, { typeName: 'ReferenceObjectExtensions' });

package/dist/openapi/3.1/callback.d.ts

@@ -0,0 +1,2 @@
+export declare const callback: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>;
+//# sourceMappingURL=callback.d.ts.map

package/dist/openapi/3.1/callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/callback.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ,2HAEnB,CAAA"}

package/dist/openapi/3.1/callback.js

@@ -0,0 +1,6 @@
+import { lazy, record, string } from '@scalar/validation';
+import { pathItem } from '../../openapi/3.1/path-item.js';
+import { recursiveRef } from '../../openapi/3.1/reference.js';
+export const callback = record(string(), recursiveRef(lazy(() => pathItem)), {
+    typeName: 'CallbackObject',
+});

package/dist/openapi/3.1/components.d.ts

@@ -0,0 +1,36 @@
+export declare const components: import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
+    schemas: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    responses: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    parameters: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    examples: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    requestBodies: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    headers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    securitySchemes: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    links: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    callbacks: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    pathItems: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
+        $ref: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        get: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        put: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        post: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        delete: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        patch: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        connect: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        options: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        head: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        trace: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            url: import("@scalar/validation").StringSchema;
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            variables: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+                enum: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+                default: import("@scalar/validation").StringSchema;
+                description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            }>>>;
+        }>>>;
+        parameters: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").Schema>>;
+    }>>>>;
+}>>;
+//# sourceMappingURL=components.d.ts.map

package/dist/openapi/3.1/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/components.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BtB,CAAA"}

package/dist/openapi/3.1/components.js

@@ -0,0 +1,24 @@
+import { lazy, object, optional, record, string } from '@scalar/validation';
+import { callback } from '../../openapi/3.1/callback.js';
+import { example } from '../../openapi/3.1/example.js';
+import { link } from '../../openapi/3.1/link.js';
+import { header } from '../../openapi/3.1/media-type.js';
+import { parameter } from '../../openapi/3.1/parameter.js';
+import { pathItem } from '../../openapi/3.1/path-item.js';
+import { normalRef, recursiveRef } from '../../openapi/3.1/reference.js';
+import { requestBody } from '../../openapi/3.1/request-body.js';
+import { response } from '../../openapi/3.1/response.js';
+import { schema } from '../../openapi/3.1/schema.js';
+import { securityScheme } from '../../openapi/3.1/security-schemes.js';
+export const components = lazy(() => object({
+    schemas: optional(record(string(), normalRef(schema), { typeName: 'ComponentsSchemas' })),
+    responses: optional(record(string(), recursiveRef(lazy(() => response)), { typeName: 'ComponentsResponses' })),
+    parameters: optional(record(string(), recursiveRef(lazy(() => parameter)), { typeName: 'ComponentsParameters' })),
+    examples: optional(record(string(), recursiveRef(lazy(() => example)), { typeName: 'ComponentsExamples' })),
+    requestBodies: optional(record(string(), recursiveRef(lazy(() => requestBody)), { typeName: 'ComponentsRequestBodies' })),
+    headers: optional(record(string(), recursiveRef(lazy(() => header)), { typeName: 'ComponentsHeaders' })),
+    securitySchemes: optional(record(string(), recursiveRef(lazy(() => securityScheme)), { typeName: 'ComponentsSecuritySchemes' })),
+    links: optional(record(string(), recursiveRef(lazy(() => link)), { typeName: 'ComponentsLinks' })),
+    callbacks: optional(record(string(), recursiveRef(lazy(() => callback)), { typeName: 'ComponentsCallbacks' })),
+    pathItems: optional(record(string(), lazy(() => pathItem), { typeName: 'ComponentsPathItems' })),
+}, { typeName: 'ComponentsObject' }));

package/dist/openapi/3.1/contact.d.ts

@@ -0,0 +1,6 @@
+export declare const contact: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    email: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=contact.d.ts.map

package/dist/openapi/3.1/contact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/contact.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;EAYnB,CAAA"}

package/dist/openapi/3.1/contact.js

@@ -0,0 +1,8 @@
+import { object, optional, string } from '@scalar/validation';
+export const contact = object({
+    name: optional(string({ typeComment: 'The name of the contact.' })),
+    url: optional(string({ typeComment: 'The URI for the contact information. This MUST be in the form of a URI.' })),
+    email: optional(string({
+        typeComment: 'The email address of the contact person/organization. This MUST be in the form of an email address.',
+    })),
+}, { typeName: 'ContactObject' });

package/dist/openapi/3.1/discriminator.d.ts

@@ -0,0 +1,5 @@
+export declare const discriminatorObject: import("@scalar/validation").ObjectSchema<{
+    propertyName: import("@scalar/validation").StringSchema;
+    mapping: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+}>;
+//# sourceMappingURL=discriminator.d.ts.map

package/dist/openapi/3.1/discriminator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminator.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/discriminator.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;EAa/B,CAAA"}

package/dist/openapi/3.1/discriminator.js

@@ -0,0 +1,9 @@
+import { object, optional, record, string } from '@scalar/validation';
+export const discriminatorObject = object({
+    propertyName: string({
+        typeComment: 'REQUIRED. The name of the property in the payload that will hold the discriminating value. This property SHOULD be required in the payload schema, as the behavior when the property is absent is undefined.',
+    }),
+    mapping: optional(record(string(), string(), {
+        typeComment: 'An object to hold mappings between payload values and schema names or URI references.',
+    })),
+}, { typeName: 'DiscriminatorObject' });