@scalar/schemas 0.2.0 → 0.3.0

package/dist/asyncapi/3.1/security-scheme.js

@@ -0,0 +1,39 @@
+import { array, literal, object, optional, string, union } from '@scalar/validation';
+import { asyncApiOAuthFlowsObject } from './oauth.js';
+import { recursiveRef } from './reference.js';
+/** Security Scheme Object | Reference Object */
+export const asyncApiSecuritySchemeObject = recursiveRef(object({
+    type: union([
+        literal('userPassword'),
+        literal('apiKey'),
+        literal('X509'),
+        literal('symmetricEncryption'),
+        literal('asymmetricEncryption'),
+        literal('httpApiKey'),
+        literal('http'),
+        literal('oauth2'),
+        literal('openIdConnect'),
+        literal('plain'),
+        literal('scramSha256'),
+        literal('scramSha512'),
+        literal('gssapi'),
+    ], {
+        typeComment: 'REQUIRED. Security scheme type: userPassword, apiKey, X509, symmetricEncryption, asymmetricEncryption, httpApiKey, http, oauth2, openIdConnect, plain, scramSha256, scramSha512, gssapi.',
+    }),
+    description: optional(string({
+        typeComment: 'A short description for security scheme. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    name: optional(string({ typeComment: 'REQUIRED for httpApiKey. The name of the header, query or cookie parameter.' })),
+    'in': optional(union([literal('user'), literal('password'), literal('query'), literal('header'), literal('cookie')], {
+        typeComment: 'REQUIRED for apiKey and httpApiKey. Location of the API key: user, password, query, header, or cookie.',
+    })),
+    scheme: optional(string({
+        typeComment: 'REQUIRED for http. The name of the HTTP Authorization scheme to be used in the Authorization header.',
+    })),
+    bearerFormat: optional(string({ typeComment: 'A hint to the client to identify how the bearer token is formatted.' })),
+    flows: optional(recursiveRef(asyncApiOAuthFlowsObject)),
+    openIdConnectUrl: optional(string({
+        typeComment: 'REQUIRED for openIdConnect. OpenId Connect URL to discover OAuth2 configuration values (absolute URL).',
+    })),
+    scopes: optional(array(string(), { typeComment: 'List of the needed scope names for oauth2 and openIdConnect.' })),
+}, { typeName: 'AsyncApiSecuritySchemeObject' }));

package/dist/asyncapi/3.1/server-variable.d.ts

@@ -0,0 +1,3 @@
+/** Server Variable Object | Reference Object */
+export declare const asyncApiServerVariableObject: import("@scalar/validation").Schema;
+//# sourceMappingURL=server-variable.d.ts.map

package/dist/asyncapi/3.1/server-variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-variable.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/server-variable.ts"],"names":[],"mappings":"AAIA,gDAAgD;AAChD,eAAO,MAAM,4BAA4B,qCAmBxC,CAAA"}

package/dist/asyncapi/3.1/server-variable.js

@@ -0,0 +1,13 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { recursiveRef } from './reference.js';
+/** Server Variable Object | Reference Object */
+export const asyncApiServerVariableObject = recursiveRef(object({
+    enum: optional(array(string(), { typeComment: 'An enumeration of string values for substitution.' })),
+    default: optional(string({
+        typeComment: 'The default value to use for substitution, and to send, if an alternate value is not supplied.',
+    })),
+    description: optional(string({
+        typeComment: 'An optional description for the server variable. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    examples: optional(array(string(), { typeComment: 'Examples of the server variable.' })),
+}, { typeName: 'AsyncApiServerVariableObject' }));

package/dist/asyncapi/3.1/server.d.ts

@@ -0,0 +1,4 @@
+/** Server Object | Reference Object */
+export declare const asyncApiServerObject: import("@scalar/validation").Schema;
+export declare const asyncApiServersObject: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>;
+//# sourceMappingURL=server.d.ts.map

package/dist/asyncapi/3.1/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/server.ts"],"names":[],"mappings":"AASA,uCAAuC;AACvC,eAAO,MAAM,oBAAoB,qCAwChC,CAAA;AAED,eAAO,MAAM,qBAAqB,2HAGhC,CAAA"}

package/dist/asyncapi/3.1/server.js

@@ -0,0 +1,36 @@
+import { array, object, optional, record, string } from '@scalar/validation';
+import { asyncApiServerBindingsObject } from './bindings.js';
+import { asyncApiExternalDocumentationObject } from './external-documentation.js';
+import { recursiveRef } from './reference.js';
+import { asyncApiSecuritySchemeObject } from './security-scheme.js';
+import { asyncApiServerVariableObject } from './server-variable.js';
+import { asyncApiTagsObject } from './tag.js';
+/** Server Object | Reference Object */
+export const asyncApiServerObject = recursiveRef(object({
+    host: string({
+        typeComment: 'REQUIRED. The server host name. It MAY include the port. Supports Server Variables in {braces}.',
+    }),
+    protocol: string({ typeComment: 'REQUIRED. The protocol this server supports for connection.' }),
+    protocolVersion: optional(string({ typeComment: 'The version of the protocol used for connection (for example 0-9-1 for AMQP).' })),
+    pathname: optional(string({
+        typeComment: 'The path to a resource in the host. Supports Server Variables in {braces}.',
+    })),
+    description: optional(string({
+        typeComment: 'An optional string describing the server. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    title: optional(string({ typeComment: 'A human-friendly title for the server.' })),
+    summary: optional(string({ typeComment: 'A short summary of the server.' })),
+    variables: optional(record(string(), asyncApiServerVariableObject, {
+        typeComment: 'Map between a variable name and its Server Variable Object or Reference Object.',
+    })),
+    security: optional(array(asyncApiSecuritySchemeObject, {
+        typeComment: 'Alternative security schemes for this server; only one of the security scheme objects need to be satisfied.',
+    })),
+    tags: optional(asyncApiTagsObject),
+    externalDocs: optional(asyncApiExternalDocumentationObject),
+    bindings: optional(recursiveRef(asyncApiServerBindingsObject)),
+}, { typeName: 'AsyncApiServerObject' }));
+export const asyncApiServersObject = record(string(), asyncApiServerObject, {
+    typeName: 'AsyncApiServersObject',
+    typeComment: 'Map of server name to Server Object or Reference Object.',
+});

package/dist/asyncapi/3.1/tag.d.ts

@@ -0,0 +1,4 @@
+/** Tag Object | Reference Object */
+export declare const asyncApiTagObject: import("@scalar/validation").Schema;
+export declare const asyncApiTagsObject: import("@scalar/validation").ArraySchema<import("@scalar/validation").Schema>;
+//# sourceMappingURL=tag.d.ts.map

package/dist/asyncapi/3.1/tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/asyncapi/3.1/tag.ts"],"names":[],"mappings":"AAKA,oCAAoC;AACpC,eAAO,MAAM,iBAAiB,qCAa7B,CAAA;AAED,eAAO,MAAM,kBAAkB,+EAG7B,CAAA"}

package/dist/asyncapi/3.1/tag.js

@@ -0,0 +1,15 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { asyncApiExternalDocumentationObject } from './external-documentation.js';
+import { recursiveRef } from './reference.js';
+/** Tag Object | Reference Object */
+export const asyncApiTagObject = recursiveRef(object({
+    name: string({ typeComment: 'REQUIRED. The name of the tag.' }),
+    description: optional(string({
+        typeComment: 'A short description for the tag. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    externalDocs: optional(asyncApiExternalDocumentationObject),
+}, { typeName: 'AsyncApiTagObject' }));
+export const asyncApiTagsObject = array(asyncApiTagObject, {
+    typeName: 'AsyncApiTagsObject',
+    typeComment: 'A list of Tag Objects (entries MAY be Reference Objects).',
+});

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

@@ -0,0 +1,21 @@
+/**
+ * OpenAPI document-level Scalar extensions.
+ *
+ * Applied on the root API description (OpenAPI `info` or document root). Includes workspace metadata,
+ * environments, navigation state, registry sync fields, and document lifecycle flags.
+ */
+export { XInternal } from './x-internal.js';
+export { XOriginalAasVersion } from './x-original-aas-version.js';
+export { XOriginalOasVersion } from './x-original-oas-version.js';
+export { XScalarEnvVar, XScalarEnvironment, XScalarEnvironments } from './x-scalar-environments.js';
+export { XScalarIcon } from './x-scalar-icon.js';
+export { XScalarIgnore } from './x-scalar-ignore.js';
+export { XScalarIsDirty } from './x-scalar-is-dirty.js';
+export { XScalarNavigation } from './x-scalar-navigation.js';
+export { XScalarOriginalDocumentHash } from './x-scalar-original-document-hash.js';
+export { XScalarOriginalSourceUrl } from './x-scalar-original-source-url.js';
+export { XScalarRegistryMeta } from './x-scalar-registry-meta.js';
+export { XScalarSdkInstallation } from './x-scalar-sdk-installation.js';
+export { XScalarWatchMode } from './x-scalar-watch-mode.js';
+export { XTags } from './x-tags.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAChG,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAA;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAA;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA"}

package/dist/extensions/document/index.js

@@ -0,0 +1,20 @@
+/**
+ * OpenAPI document-level Scalar extensions.
+ *
+ * Applied on the root API description (OpenAPI `info` or document root). Includes workspace metadata,
+ * environments, navigation state, registry sync fields, and document lifecycle flags.
+ */
+export { XInternal } from './x-internal.js';
+export { XOriginalAasVersion } from './x-original-aas-version.js';
+export { XOriginalOasVersion } from './x-original-oas-version.js';
+export { XScalarEnvVar, XScalarEnvironment, XScalarEnvironments } from './x-scalar-environments.js';
+export { XScalarIcon } from './x-scalar-icon.js';
+export { XScalarIgnore } from './x-scalar-ignore.js';
+export { XScalarIsDirty } from './x-scalar-is-dirty.js';
+export { XScalarNavigation } from './x-scalar-navigation.js';
+export { XScalarOriginalDocumentHash } from './x-scalar-original-document-hash.js';
+export { XScalarOriginalSourceUrl } from './x-scalar-original-source-url.js';
+export { XScalarRegistryMeta } from './x-scalar-registry-meta.js';
+export { XScalarSdkInstallation } from './x-scalar-sdk-installation.js';
+export { XScalarWatchMode } from './x-scalar-watch-mode.js';
+export { XTags } from './x-tags.js';

package/dist/extensions/document/x-internal.d.ts

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

package/dist/extensions/document/x-internal.d.ts.map

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

package/dist/extensions/document/x-internal.js

@@ -0,0 +1,11 @@
+import { boolean, object, optional } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XInternal = object({
+    'x-internal': optional(boolean({ typeComment: 'When true, hides the entity from public documentation' })),
+}, {
+    typeName: 'XInternal',
+    typeComment: typeCommentWithExample('Marks an entity as internal (hidden from external consumers).', {
+        language: 'yaml',
+        body: 'x-internal: true',
+    }),
+});

package/dist/extensions/document/x-original-aas-version.d.ts

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

package/dist/extensions/document/x-original-aas-version.d.ts.map

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

package/dist/extensions/document/x-original-aas-version.js

@@ -0,0 +1,8 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XOriginalAasVersion = object({
+    'x-original-aas-version': optional(string({ typeComment: 'Original AsyncAPI Specification version the document was loaded with.' })),
+}, {
+    typeName: 'XOriginalAasVersion',
+    typeComment: typeCommentWithExample('Original AsyncAPI Specification version of the source document before ingestion.', { language: 'yaml', body: 'x-original-aas-version: "3.0.0"' }),
+});

package/dist/extensions/document/x-original-oas-version.d.ts

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

package/dist/extensions/document/x-original-oas-version.d.ts.map

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

package/dist/extensions/document/x-original-oas-version.js

@@ -0,0 +1,8 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XOriginalOasVersion = object({
+    'x-original-oas-version': optional(string({ typeComment: 'Original OpenAPI Specification version of the source document.' })),
+}, {
+    typeName: 'XOriginalOasVersion',
+    typeComment: typeCommentWithExample('Original OpenAPI Specification version of the source document before ingestion.', { language: 'yaml', body: 'x-original-oas-version: "3.1.0"' }),
+});

package/dist/extensions/document/x-scalar-environments.d.ts

@@ -0,0 +1,34 @@
+/** A scalar environment variable */
+export declare const XScalarEnvVar: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    value: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        default: import("@scalar/validation").StringSchema;
+    }>, import("@scalar/validation").StringSchema]>;
+}>;
+/** An environment definition */
+export declare const XScalarEnvironment: import("@scalar/validation").ObjectSchema<{
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    color: import("@scalar/validation").StringSchema;
+    variables: import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        value: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            default: import("@scalar/validation").StringSchema;
+        }>, import("@scalar/validation").StringSchema]>;
+    }>>;
+}>;
+export declare const XScalarEnvironments: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-environments': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        color: import("@scalar/validation").StringSchema;
+        variables: import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").StringSchema;
+            value: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+                description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+                default: import("@scalar/validation").StringSchema;
+            }>, import("@scalar/validation").StringSchema]>;
+        }>>;
+    }>>>;
+}>;
+//# sourceMappingURL=x-scalar-environments.d.ts.map

package/dist/extensions/document/x-scalar-environments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-environments.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-environments.ts"],"names":[],"mappings":"AAIA,oCAAoC;AACpC,eAAO,MAAM,aAAa;;;;;;EAWzB,CAAA;AAED,gCAAgC;AAChC,eAAO,MAAM,kBAAkB;;;;;;;;;;EAc9B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAuB/B,CAAA"}

package/dist/extensions/document/x-scalar-environments.js

@@ -0,0 +1,41 @@
+import { array, object, optional, record, string, union } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/** A scalar environment variable */
+export const XScalarEnvVar = object({
+    name: string({ typeComment: 'Variable name' }),
+    value: union([object({ description: optional(string()), default: string() }), string()], {
+        typeComment: 'Variable value as a string, or an object with description and default',
+    }),
+}, {
+    typeName: 'XScalarEnvVar',
+    typeComment: 'An environment variable definition',
+});
+/** An environment definition */
+export const XScalarEnvironment = object({
+    description: optional(string({ typeComment: 'Optional description for the environment' })),
+    color: string({
+        typeComment: 'Color for the environment (for example a hex value)',
+    }),
+    variables: array(XScalarEnvVar, {
+        typeComment: 'Variables available in this environment',
+    }),
+}, {
+    typeName: 'XScalarEnvironment',
+    typeComment: 'A named environment with variables and display color',
+});
+export const XScalarEnvironments = object({
+    'x-scalar-environments': optional(record(string(), XScalarEnvironment, {
+        typeComment: 'Environments keyed by name',
+    })),
+}, {
+    typeName: 'XScalarEnvironments',
+    typeComment: typeCommentWithExample('Named environments with variables for the API client (base URLs, tokens, etc.).', {
+        language: 'yaml',
+        body: `x-scalar-environments:
+  production:
+    color: "#00ff00"
+    variables:
+      - name: apiKey
+        value: prod-key`,
+    }),
+});

package/dist/extensions/document/x-scalar-icon.d.ts

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

package/dist/extensions/document/x-scalar-icon.d.ts.map

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

package/dist/extensions/document/x-scalar-icon.js

@@ -0,0 +1,11 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarIcon = object({
+    'x-scalar-icon': optional(string({ typeComment: 'Icon identifier or URL for the API description' })),
+}, {
+    typeName: 'XScalarIcon',
+    typeComment: typeCommentWithExample('A custom icon representing the API description in the Scalar UI.', {
+        language: 'yaml',
+        body: 'x-scalar-icon: rocket',
+    }),
+});

package/dist/extensions/document/x-scalar-ignore.d.ts

@@ -0,0 +1,5 @@
+/** Internal extension to mark an entity as ignored in the Scalar UI */
+export declare const XScalarIgnore: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-ignore': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>;
+//# sourceMappingURL=x-scalar-ignore.d.ts.map

package/dist/extensions/document/x-scalar-ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-ignore.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-ignore.ts"],"names":[],"mappings":"AAIA,uEAAuE;AACvE,eAAO,MAAM,aAAa;;EAWzB,CAAA"}

package/dist/extensions/document/x-scalar-ignore.js

@@ -0,0 +1,12 @@
+import { boolean, object, optional } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+/** Internal extension to mark an entity as ignored in the Scalar UI */
+export const XScalarIgnore = object({
+    'x-scalar-ignore': optional(boolean({ typeComment: 'When true, the entity is hidden or ignored in the UI' })),
+}, {
+    typeName: 'XScalarIgnore',
+    typeComment: typeCommentWithExample('Internal extension to mark an entity as ignored in the Scalar UI.', {
+        language: 'yaml',
+        body: 'x-scalar-ignore: true',
+    }),
+});

package/dist/extensions/document/x-scalar-is-dirty.d.ts

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

package/dist/extensions/document/x-scalar-is-dirty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-is-dirty.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-is-dirty.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;EAe1B,CAAA"}

package/dist/extensions/document/x-scalar-is-dirty.js

@@ -0,0 +1,13 @@
+import { boolean, object, optional } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarIsDirty = object({
+    'x-scalar-is-dirty': optional(boolean({
+        typeComment: 'When true, the document has unsaved changes',
+    })),
+}, {
+    typeName: 'XScalarIsDirty',
+    typeComment: typeCommentWithExample('Tracks whether the document has been modified since it was last saved.', {
+        language: 'yaml',
+        body: 'x-scalar-is-dirty: true',
+    }),
+});

package/dist/extensions/document/x-scalar-navigation.d.ts

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

package/dist/extensions/document/x-scalar-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-navigation.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-navigation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;EAa7B,CAAA"}

package/dist/extensions/document/x-scalar-navigation.js

@@ -0,0 +1,9 @@
+import { any, object, optional } from '@scalar/validation';
+export const XScalarNavigation = object({
+    'x-scalar-navigation': optional(any({
+        typeComment: 'Serialized client navigation tree (`TraversedDocument`) for this API description',
+    })),
+}, {
+    typeName: 'XScalarNavigation',
+    typeComment: 'Client-side navigation tree persisted on the document. Matches `TraversedDocumentObjectRef` in strict OpenAPI schemas.',
+});

package/dist/extensions/document/x-scalar-original-document-hash.d.ts

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

package/dist/extensions/document/x-scalar-original-document-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-original-document-hash.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-original-document-hash.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,2BAA2B;;EAavC,CAAA"}

package/dist/extensions/document/x-scalar-original-document-hash.js

@@ -0,0 +1,10 @@
+import { object, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarOriginalDocumentHash = object({
+    'x-scalar-original-document-hash': string({
+        typeComment: 'Hash of the document as originally loaded from an external source',
+    }),
+}, {
+    typeName: 'XScalarOriginalDocumentHash',
+    typeComment: typeCommentWithExample('Tracks the original document hash when loading from an external source. Used to detect modifications since last save.', { language: 'yaml', body: 'x-scalar-original-document-hash: "abc123"' }),
+});

package/dist/extensions/document/x-scalar-original-source-url.d.ts

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

package/dist/extensions/document/x-scalar-original-source-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-original-source-url.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-original-source-url.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,wBAAwB;;EAapC,CAAA"}

package/dist/extensions/document/x-scalar-original-source-url.js

@@ -0,0 +1,8 @@
+import { object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarOriginalSourceUrl = object({
+    'x-scalar-original-source-url': optional(string({ typeComment: 'Original document source URL when loaded from an external source' })),
+}, {
+    typeName: 'XScalarOriginalSourceUrl',
+    typeComment: typeCommentWithExample('Original document source URL when the API description was loaded from an external source.', { language: 'yaml', body: 'x-scalar-original-source-url: https://example.com/openapi.yaml' }),
+});

package/dist/extensions/document/x-scalar-registry-meta.d.ts

@@ -0,0 +1,11 @@
+export declare const XScalarRegistryMeta: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-registry-meta': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        namespace: import("@scalar/validation").StringSchema;
+        slug: import("@scalar/validation").StringSchema;
+        version: import("@scalar/validation").StringSchema;
+        commitHash: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        conflictCheckedAgainstHash: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        hasConflict: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>;
+}>;
+//# sourceMappingURL=x-scalar-registry-meta.d.ts.map

package/dist/extensions/document/x-scalar-registry-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-registry-meta.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-registry-meta.ts"],"names":[],"mappings":"AAkCA,eAAO,MAAM,mBAAmB;;;;;;;;;EAc/B,CAAA"}

package/dist/extensions/document/x-scalar-registry-meta.js

@@ -0,0 +1,31 @@
+import { boolean, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+const XScalarRegistryMetaInner = object({
+    namespace: string({ typeComment: 'The namespace under which this registry meta is scoped.' }),
+    slug: string({ typeComment: 'A unique slug identifier for this registry meta within the namespace.' }),
+    version: string({ typeComment: 'The version of the registry meta.' }),
+    commitHash: optional(string({
+        typeComment: 'Last known commit hash of this document. Is going to be used to track if the document has been modified since it was last saved.',
+    })),
+    conflictCheckedAgainstHash: optional(string({
+        typeComment: 'Registry commit hash that the cached `hasConflict` flag was computed against. When the registry advertises a different hash later, the cached result is stale and the conflict check must be re-run.',
+    })),
+    hasConflict: optional(boolean({
+        typeComment: 'Cached outcome of the last conflict check, valid only while `conflictCheckedAgainstHash` matches the registry current hash for this version.',
+    })),
+}, {
+    typeName: 'XScalarRegistryMetaInner',
+    typeComment: 'Registry meta namespace and slug',
+});
+export const XScalarRegistryMeta = object({
+    'x-scalar-registry-meta': optional(XScalarRegistryMetaInner),
+}, {
+    typeName: 'XScalarRegistryMeta',
+    typeComment: typeCommentWithExample('Registry sync metadata for a document published to Scalar Registry.', {
+        language: 'yaml',
+        body: `x-scalar-registry-meta:
+  namespace: acme
+  slug: public-api
+  version: "1.0.0"`,
+    }),
+});

package/dist/extensions/document/x-scalar-sdk-installation.d.ts

@@ -0,0 +1,8 @@
+export declare const XScalarSdkInstallation: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-sdk-installation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").StringSchema;
+        source: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>>;
+}>;
+//# sourceMappingURL=x-scalar-sdk-installation.d.ts.map

package/dist/extensions/document/x-scalar-sdk-installation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-sdk-installation.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-sdk-installation.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,sBAAsB;;;;;;EAiBlC,CAAA"}

package/dist/extensions/document/x-scalar-sdk-installation.js

@@ -0,0 +1,23 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+const XScalarSdkInstallationItem = object({
+    lang: string({ typeComment: 'Programming language or platform (for example `shell`, `javascript`)' }),
+    source: optional(string({ typeComment: 'Installation command or snippet source' })),
+    description: optional(string({ typeComment: 'Human-readable description of this installation option' })),
+}, {
+    typeName: 'XScalarSdkInstallationItem',
+    typeComment: 'One SDK installation instruction block',
+});
+export const XScalarSdkInstallation = object({
+    'x-scalar-sdk-installation': optional(array(XScalarSdkInstallationItem, {
+        typeComment: 'Installation instructions shown in the API reference',
+    })),
+}, {
+    typeName: 'XScalarSdkInstallation',
+    typeComment: typeCommentWithExample('Scalar SDK installation instructions for the API description.', {
+        language: 'yaml',
+        body: `x-scalar-sdk-installation:
+  - lang: shell
+    source: npm install @scalar/api-client`,
+    }),
+});

package/dist/extensions/document/x-scalar-watch-mode.d.ts

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

package/dist/extensions/document/x-scalar-watch-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-scalar-watch-mode.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-scalar-watch-mode.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB;;EAa5B,CAAA"}

package/dist/extensions/document/x-scalar-watch-mode.js

@@ -0,0 +1,8 @@
+import { boolean, object, optional } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XScalarWatchMode = object({
+    'x-scalar-watch-mode': optional(boolean({ typeComment: 'When true, the document is watched for external file changes' })),
+}, {
+    typeName: 'XScalarWatchMode',
+    typeComment: typeCommentWithExample('Whether the document is in watch mode (reloads when the source file changes).', { language: 'yaml', body: 'x-scalar-watch-mode: true' }),
+});

package/dist/extensions/document/x-tags.d.ts

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

package/dist/extensions/document/x-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-tags.d.ts","sourceRoot":"","sources":["../../../src/extensions/document/x-tags.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,KAAK;;EAiBjB,CAAA"}

package/dist/extensions/document/x-tags.js

@@ -0,0 +1,15 @@
+import { array, object, optional, string } from '@scalar/validation';
+import { typeCommentWithExample } from '../type-comment.js';
+export const XTags = object({
+    'x-tags': optional(array(string(), {
+        typeComment: 'Ordered list of tag names for this schema object',
+    })),
+}, {
+    typeName: 'XTags',
+    typeComment: typeCommentWithExample('Custom tag ordering hints for schema objects in the sidebar.', {
+        language: 'yaml',
+        body: `x-tags:
+  - users
+  - admin`,
+    }),
+});

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

@@ -0,0 +1,7 @@
+/**
+ * Example Scalar extensions.
+ *
+ * Applied on OpenAPI examples (parameter examples, request body examples, etc.).
+ */
+export { XDisabled } from './x-disabled.js';
+//# sourceMappingURL=index.d.ts.map