@scalar/workspace-store 0.41.2 → 0.43.0

package/dist/request-example/context/servers.js

@@ -0,0 +1,89 @@
+import { combineUrlAndPath } from '@scalar/helpers/url/merge-urls';
+/**
+ * Retrieves and processes servers from an OpenAPI document.
+ *
+ * This function handles several scenarios:
+ * 1. No servers provided - creates a default server from document URL or fallback
+ * 2. Invalid server configurations - filters them out with warnings
+ * 3. Relative URLs - resolves them to absolute URLs using available base URLs
+ *
+ * @param servers - Array of OpenAPI server objects from the document
+ * @param options - Configuration options for server processing
+ * @returns Array of validated Server entities
+ */
+export function getServers(servers, options = {}) {
+    // Handle invalid server array
+    if (!Array.isArray(servers)) {
+        return [];
+    }
+    // Process each server and filter out invalid ones
+    const validServers = servers.map((server) => processServerObject(server, options));
+    return validServers;
+}
+/**
+ * Extracts the base URL (protocol + hostname) from a document URL.
+ * Returns undefined if the URL is invalid.
+ */
+function extractBaseUrlFromDocumentUrl(documentUrl) {
+    try {
+        const url = new URL(documentUrl);
+        const port = url.port ? `:${url.port}` : '';
+        return `${url.protocol}//${url.hostname}${port}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Gets the fallback URL from window.location.origin if available.
+ */
+function getFallbackUrl() {
+    if (typeof window === 'undefined' || typeof window?.location?.origin !== 'string') {
+        return undefined;
+    }
+    return window.location.origin;
+}
+/**
+ * Resolves a relative server URL to an absolute URL using available base URLs.
+ * Uses a priority system: baseServerURL > documentUrl > fallbackUrl.
+ */
+function resolveRelativeServerUrl(serverUrl, options) {
+    const { baseServerUrl: baseServerURL, documentUrl } = options;
+    // Priority 1: Use provided base server URL
+    if (baseServerURL) {
+        return combineUrlAndPath(baseServerURL, serverUrl);
+    }
+    // Priority 2: Extract base URL from document URL
+    if (documentUrl) {
+        const baseUrl = extractBaseUrlFromDocumentUrl(documentUrl);
+        if (baseUrl) {
+            return combineUrlAndPath(baseUrl, serverUrl);
+        }
+    }
+    // Priority 3: Use fallback URL (window.location.origin)
+    const fallbackUrl = getFallbackUrl();
+    if (fallbackUrl) {
+        return combineUrlAndPath(fallbackUrl, serverUrl);
+    }
+    // If no base URL is available, return the original URL
+    return serverUrl;
+}
+/**
+ * Processes a single server object, handling validation and URL resolution.
+ */
+function processServerObject(server, options) {
+    // Resolve relative URLs to absolute URLs
+    if (server.url?.startsWith('/')) {
+        server.url = resolveRelativeServerUrl(server.url, options);
+    }
+    return server;
+}
+export const getSelectedServer = (document, operation, configServers, servers) => {
+    const selectedServerUrl = configServers != null
+        ? document?.['x-scalar-selected-server']
+        : (operation?.['x-scalar-selected-server'] ?? document?.['x-scalar-selected-server']);
+    if (selectedServerUrl == null) {
+        return servers[0] ?? null;
+    }
+    return servers.find(({ url }) => url === selectedServerUrl) ?? null;
+};

package/dist/request-example/index.d.ts

@@ -0,0 +1,5 @@
+export { buildRequest, buildRequestSecurity, deSerializeParameter, filterGlobalCookie, getEnvironmentVariables, getExample, getExampleFromBody, getExampleFromSchema, getResolvedUrl, getSelectedBodyContentType, getServerVariables, requestFactory, serializeContentValue, serializeDeepObjectStyle, serializeFormStyle, serializeFormStyleForCookies, serializePipeDelimitedStyle, serializeSimpleStyle, serializeSpaceDelimitedStyle, } from './builder/index.js';
+export type { ApiKeyObjectSecret, HttpObjectSecret, OAuth2ObjectSecret, OAuthFlowAuthorizationCodeSecret, OAuthFlowClientCredentialsSecret, OAuthFlowImplicitSecret, OAuthFlowPasswordSecret, OAuthFlowsObjectSecret, OpenIdConnectObjectSecret, SecuritySchemeObjectSecret, } from './builder/index.js';
+export { combineParams, getActiveEnvironment, getActiveProxyUrl, getRequestExampleContext, getSecurityRequirements, getSecuritySchemes, getSelectedSecurity, getSelectedServer, getServers, isAuthOptional, mergeSecurity, } from './context/index.js';
+export type { MergedSecuritySchemes } from './context/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/request-example/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/request-example/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,0BAA0B,EAC1B,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,4BAA4B,EAC5B,2BAA2B,EAC3B,oBAAoB,EACpB,4BAA4B,GAC7B,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,gCAAgC,EAChC,gCAAgC,EAChC,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,EACxB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,UAAU,EACV,cAAc,EACd,aAAa,GACd,MAAM,WAAW,CAAA;AAClB,YAAY,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA"}

package/dist/request-example/index.js

@@ -0,0 +1,2 @@
+export { buildRequest, buildRequestSecurity, deSerializeParameter, filterGlobalCookie, getEnvironmentVariables, getExample, getExampleFromBody, getExampleFromSchema, getResolvedUrl, getSelectedBodyContentType, getServerVariables, requestFactory, serializeContentValue, serializeDeepObjectStyle, serializeFormStyle, serializeFormStyleForCookies, serializePipeDelimitedStyle, serializeSimpleStyle, serializeSpaceDelimitedStyle, } from './builder/index.js';
+export { combineParams, getActiveEnvironment, getActiveProxyUrl, getRequestExampleContext, getSecurityRequirements, getSecuritySchemes, getSelectedSecurity, getSelectedServer, getServers, isAuthOptional, mergeSecurity, } from './context/index.js';

package/dist/request-example/types.d.ts

@@ -0,0 +1,14 @@
+import type { HttpMethod } from '@scalar/helpers/http/http-methods';
+export type Result<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+};
+export type RequestExampleMeta = {
+    path: string;
+    method: HttpMethod;
+    exampleName: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/request-example/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/request-example/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,MAAM,MAAM,MAAM,CAAC,CAAC,IAChB;IACE,EAAE,EAAE,IAAI,CAAA;IACR,IAAI,EAAE,CAAC,CAAA;CACR,GACD;IACE,EAAE,EAAE,KAAK,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAEL,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA"}

package/dist/request-example/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -5,4 +5,7 @@ export type XInternal = {
     /** Extension to mark an entity as internal */
     'x-internal'?: boolean;
 };
+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/schemas/extensions/document/x-internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-internal.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-internal.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;EAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,8CAA8C;IAC9C,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA"}
+{"version":3,"file":"x-internal.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-internal.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;EAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,8CAA8C;IAC9C,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,SAAS;;EAQrB,CAAA"}

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

@@ -1,4 +1,11 @@
 import { Type } from '@scalar/typebox';
+import { boolean, object, optional } from '@scalar/validation';
 export const XInternalSchema = Type.Object({
     'x-internal': Type.Optional(Type.Boolean()),
 });
+export const XInternal = object({
+    'x-internal': optional(boolean({ typeComment: 'Extension to mark an entity as internal' })),
+}, {
+    typeName: 'XInternal',
+    typeComment: 'Extension to mark an entity as internal',
+});

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

@@ -5,6 +5,13 @@ export declare const xScalarEnvVarSchema: import("@scalar/typebox").TObject<{
         default: import("@scalar/typebox").TString;
     }>, import("@scalar/typebox").TString]>;
 }>;
+export declare const XScalarEnvVar: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    value: import("@scalar/validation").UnionSchema<(import("@scalar/validation").StringSchema | import("@scalar/validation").ObjectSchema<{
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        default: import("@scalar/validation").StringSchema;
+    }>)[]>;
+}>;
 /** A scalar environment variable */
 export type XScalarEnvVar = {
     name: string;
@@ -24,6 +31,17 @@ export declare const xScalarEnvironmentSchema: import("@scalar/typebox").TObject
         }>, import("@scalar/typebox").TString]>;
     }>>;
 }>;
+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<(import("@scalar/validation").StringSchema | import("@scalar/validation").ObjectSchema<{
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            default: import("@scalar/validation").StringSchema;
+        }>)[]>;
+    }>>;
+}>;
 /** An environment definition */
 export type XScalarEnvironment = {
     /** Optional description for the environment */
@@ -46,6 +64,19 @@ export declare const xScalarEnvironmentsSchema: import("@scalar/typebox").TObjec
         }>>;
     }>>>;
 }>;
+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<(import("@scalar/validation").StringSchema | import("@scalar/validation").ObjectSchema<{
+                description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+                default: import("@scalar/validation").StringSchema;
+            }>)[]>;
+        }>>;
+    }>>>;
+}>;
 export type XScalarEnvironments = {
     /** A record of environments by name */
     'x-scalar-environments'?: Record<string, XScalarEnvironment>;

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

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-environments.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-environments.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;EAS9B,CAAA;AAEF,oCAAoC;AACpC,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EACD;QACE,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,OAAO,EAAE,MAAM,CAAA;KAChB,GACD,MAAM,CAAA;CACX,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;EAInC,CAAA;AAEF,gCAAgC;AAChC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,4BAA4B;IAC5B,SAAS,EAAE,aAAa,EAAE,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAEpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,uCAAuC;IACvC,uBAAuB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;CAC7D,CAAA"}
+{"version":3,"file":"x-scalar-environments.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-environments.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB;;;;;;EAS9B,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;EAQzB,CAAA;AAED,oCAAoC;AACpC,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EACD;QACE,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,OAAO,EAAE,MAAM,CAAA;KAChB,GACD,MAAM,CAAA;CACX,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;EAInC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;EAc9B,CAAA;AAED,gCAAgC;AAChC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,4BAA4B;IAC5B,SAAS,EAAE,aAAa,EAAE,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAEpC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAQ/B,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,uCAAuC;IACvC,uBAAuB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;CAC7D,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, record, string, union } from '@scalar/validation';
 export const xScalarEnvVarSchema = Type.Object({
     name: Type.String(),
     value: Type.Union([
@@ -9,11 +10,35 @@ export const xScalarEnvVarSchema = Type.Object({
         Type.String(),
     ]),
 });
+export const XScalarEnvVar = object({
+    name: string(),
+    value: union([object({ description: optional(string()), default: string() }), string()]),
+}, {
+    typeName: 'XScalarEnvVar',
+});
 export const xScalarEnvironmentSchema = Type.Object({
     description: Type.Optional(Type.String()),
     color: Type.String({ default: '#FFFFFF' }),
     variables: Type.Array(xScalarEnvVarSchema),
 });
+export const XScalarEnvironment = object({
+    description: optional(string()),
+    color: string({
+        typeComment: 'Color for the environment',
+    }),
+    variables: array(XScalarEnvVar, {
+        typeComment: 'An array of variables',
+    }),
+}, {
+    typeName: 'XScalarEnvironment',
+    typeComment: 'A map of environments by name',
+});
 export const xScalarEnvironmentsSchema = Type.Object({
     'x-scalar-environments': Type.Optional(Type.Record(Type.String(), xScalarEnvironmentSchema)),
 });
+export const XScalarEnvironments = object({
+    'x-scalar-environments': optional(record(string(), XScalarEnvironment)),
+}, {
+    typeName: 'XScalarEnvironments',
+    typeComment: 'A record of environments by name',
+});

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

@@ -5,4 +5,7 @@ export type XScalarIcon = {
     /** A custom icon representing the collection */
     'x-scalar-icon'?: string;
 };
+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/schemas/extensions/document/x-scalar-icon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-icon.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-icon.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;EAE5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,gDAAgD;IAChD,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA"}
+{"version":3,"file":"x-scalar-icon.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-icon.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB;;EAE5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,gDAAgD;IAChD,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,WAAW;;EAQvB,CAAA"}

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

@@ -1,4 +1,11 @@
 import { Type } from '@scalar/typebox';
+import { object, optional, string } from '@scalar/validation';
 export const XScalarIconSchema = Type.Object({
     'x-scalar-icon': Type.Optional(Type.String()),
 });
+export const XScalarIcon = object({
+    'x-scalar-icon': optional(string()),
+}, {
+    typeName: 'XScalarIcon',
+    typeComment: 'A custom icon representing the collection',
+});

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

@@ -2,7 +2,10 @@ export declare const XScalarIgnoreSchema: import("@scalar/typebox").TObject<{
     'x-scalar-ignore': import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
 }>;
 export type XScalarIgnore = {
-    /** Interal extension to mark an entity as ignored */
+    /** Internal extension to mark an entity as ignored */
     'x-scalar-ignore'?: boolean;
 };
+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/schemas/extensions/document/x-scalar-ignore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-ignore.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-ignore.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;EAE9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA"}
+{"version":3,"file":"x-scalar-ignore.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-ignore.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB;;EAE9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,sDAAsD;IACtD,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED,eAAO,MAAM,aAAa;;EAQzB,CAAA"}

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

@@ -1,4 +1,11 @@
 import { Type } from '@scalar/typebox';
+import { boolean, object, optional } from '@scalar/validation';
 export const XScalarIgnoreSchema = Type.Object({
     'x-scalar-ignore': Type.Optional(Type.Boolean()),
 });
+export const XScalarIgnore = object({
+    'x-scalar-ignore': optional(boolean()),
+}, {
+    typeName: 'XScalarIgnore',
+    typeComment: 'Internal extension to mark an entity as ignored',
+});

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

@@ -40,4 +40,7 @@ export type XScalarIsDirty = {
     /** Whether the document state is dirty, this is used to track if the document has been modified since it was last saved */
     'x-scalar-is-dirty'?: boolean;
 };
+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/schemas/extensions/document/x-scalar-is-dirty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-is-dirty.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-is-dirty.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB;IAC/B,2HAA2H;;EAE3H,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,2HAA2H;IAC3H,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA"}
+{"version":3,"file":"x-scalar-is-dirty.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-is-dirty.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB;IAC/B,2HAA2H;;EAE3H,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,2HAA2H;IAC3H,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,cAAc;;EAa1B,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { boolean, object, optional } from '@scalar/validation';
 /**
  * Schema for the "x-scalar-is-dirty" OpenAPI extension.
  * This extension allows specifying an optional boolean value,
@@ -20,3 +21,11 @@ export const XScalarIsDirtySchema = Type.Object({
     /** Whether the document state is dirty, this is used to track if the document has been modified since it was last saved */
     'x-scalar-is-dirty': Type.Optional(Type.Boolean()),
 });
+export const XScalarIsDirty = object({
+    'x-scalar-is-dirty': optional(boolean({
+        typeComment: 'Whether the document state is dirty, this is used to track if the document has been modified since it was last saved',
+    })),
+}, {
+    typeName: 'XScalarIsDirty',
+    typeComment: 'Tracks whether the document has been modified since it was last saved',
+});

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

@@ -19,4 +19,7 @@ export type XScalarOriginalDocumentHash = {
     /** Original input document hash */
     'x-scalar-original-document-hash': string;
 };
+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/schemas/extensions/document/x-scalar-original-document-hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-original-document-hash.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-original-document-hash.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iCAAiC;IAC5C,mCAAmC;;EAEnC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,mCAAmC;IACnC,iCAAiC,EAAE,MAAM,CAAA;CAC1C,CAAA"}
+{"version":3,"file":"x-scalar-original-document-hash.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-original-document-hash.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iCAAiC;IAC5C,mCAAmC;;EAEnC,CAAA;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,mCAAmC;IACnC,iCAAiC,EAAE,MAAM,CAAA;CAC1C,CAAA;AAED,eAAO,MAAM,2BAA2B;;EAQvC,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { object, string } from '@scalar/validation';
 /**
  * Schema for the "x-scalar-original-document-hash" OpenAPI extension.
  * This extension allows specifying an optional string value,
@@ -16,3 +17,9 @@ export const XScalarOriginalDocumentHashSchema = Type.Object({
     /** Original input document hash */
     'x-scalar-original-document-hash': Type.String(),
 });
+export const XScalarOriginalDocumentHash = object({
+    'x-scalar-original-document-hash': string({ typeComment: 'Original input document hash' }),
+}, {
+    typeName: 'XScalarOriginalDocumentHash',
+    typeComment: 'Original input document hash',
+});

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

@@ -28,4 +28,10 @@ export type XScalarRegistryMeta = {
         slug: string;
     };
 };
+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;
+    }>>;
+}>;
 //# sourceMappingURL=x-scalar-registry-meta.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-registry-meta.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-registry-meta.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB;IACpC;;OAEG;;QAGC;;WAEG;;QAEH;;WAEG;;;EAIP,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC;;OAEG;IACH,wBAAwB,CAAC,EAAE;QACzB;;WAEG;QACH,SAAS,EAAE,MAAM,CAAA;QACjB;;WAEG;QACH,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;CACF,CAAA"}
+{"version":3,"file":"x-scalar-registry-meta.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-registry-meta.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,yBAAyB;IACpC;;OAEG;;QAbH;;WAEG;;QAEH;;WAEG;;;EASH,CAAA;AAaF,MAAM,MAAM,mBAAmB,GAAG;IAChC;;OAEG;IACH,wBAAwB,CAAC,EAAE;QACzB;;WAEG;QACH,SAAS,EAAE,MAAM,CAAA;QACjB;;WAEG;QACH,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;CACF,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;EAQ/B,CAAA"}

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

@@ -1,16 +1,31 @@
 import { Type } from '@scalar/typebox';
+import { object, optional, string } from '@scalar/validation';
+const XScalarRegistryMetaInnerSchema = Type.Object({
+    /**
+     * The namespace under which this registry meta is scoped.
+     */
+    'namespace': Type.String(),
+    /**
+     * A unique slug identifier for this registry meta within the namespace.
+     */
+    'slug': Type.String(),
+});
 export const XScalarRegistryMetaSchema = Type.Object({
     /**
      * The registry meta for the document.
      */
-    'x-scalar-registry-meta': Type.Optional(Type.Object({
-        /**
-         * The namespace under which this registry meta is scoped.
-         */
-        'namespace': Type.String(),
-        /**
-         * A unique slug identifier for this registry meta within the namespace.
-         */
-        'slug': Type.String(),
-    })),
+    'x-scalar-registry-meta': Type.Optional(XScalarRegistryMetaInnerSchema),
+});
+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.' }),
+}, {
+    typeName: 'XScalarRegistryMetaInner',
+    typeComment: 'Registry meta namespace and slug',
+});
+export const XScalarRegistryMeta = object({
+    'x-scalar-registry-meta': optional(XScalarRegistryMetaInner),
+}, {
+    typeName: 'XScalarRegistryMeta',
+    typeComment: 'The registry meta for the document',
 });

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

@@ -13,4 +13,11 @@ export type XScalarSdkInstallation = {
         description?: string;
     }[];
 };
+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/schemas/extensions/document/x-scalar-sdk-installation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-sdk-installation.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-sdk-installation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B;;;;;;EAUvC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,2CAA2C;IAC3C,2BAA2B,CAAC,EAAE;QAC5B,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,EAAE,CAAA;CACJ,CAAA"}
+{"version":3,"file":"x-scalar-sdk-installation.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-sdk-installation.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,4BAA4B;;;;;;EAEvC,CAAA;AAcF,MAAM,MAAM,sBAAsB,GAAG;IACnC,2CAA2C;IAC3C,2BAA2B,CAAC,EAAE;QAC5B,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,EAAE,CAAA;CACJ,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;EAYlC,CAAA"}

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

@@ -1,8 +1,26 @@
 import { Type } from '@scalar/typebox';
+import { array, object, optional, string } from '@scalar/validation';
+const XScalarSdkInstallationItemSchema = Type.Object({
+    lang: Type.String(),
+    source: Type.Optional(Type.String()),
+    description: Type.Optional(Type.String()),
+});
 export const XScalarSdkInstallationSchema = Type.Object({
-    'x-scalar-sdk-installation': Type.Optional(Type.Array(Type.Object({
-        lang: Type.String(),
-        source: Type.Optional(Type.String()),
-        description: Type.Optional(Type.String()),
-    }))),
+    'x-scalar-sdk-installation': Type.Optional(Type.Array(XScalarSdkInstallationItemSchema)),
+});
+const XScalarSdkInstallationItem = object({
+    lang: string(),
+    source: optional(string()),
+    description: optional(string()),
+}, {
+    typeName: 'XScalarSdkInstallationItem',
+    typeComment: 'Scalar SDK installation entry',
+});
+export const XScalarSdkInstallation = object({
+    'x-scalar-sdk-installation': optional(array(XScalarSdkInstallationItem, {
+        typeComment: 'Scalar SDK installation information',
+    })),
+}, {
+    typeName: 'XScalarSdkInstallation',
+    typeComment: 'Scalar SDK installation information',
 });

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

@@ -6,4 +6,7 @@ export type XScalarWatchMode = {
     /** Whether the document is in watch mode */
     'x-scalar-watch-mode'?: boolean;
 };
+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/schemas/extensions/document/x-scalar-watch-mode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-watch-mode.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-watch-mode.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;IACjC,4CAA4C;;EAE5C,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4CAA4C;IAC5C,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAA"}
+{"version":3,"file":"x-scalar-watch-mode.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-scalar-watch-mode.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB;IACjC,4CAA4C;;EAE5C,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4CAA4C;IAC5C,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAA;AAED,eAAO,MAAM,gBAAgB;;EAQ5B,CAAA"}

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

@@ -1,5 +1,12 @@
 import { Type } from '@scalar/typebox';
+import { boolean, object, optional } from '@scalar/validation';
 export const XScalarWatchModeSchema = Type.Object({
     /** Whether the document is in watch mode */
     'x-scalar-watch-mode': Type.Optional(Type.Boolean()),
 });
+export const XScalarWatchMode = object({
+    'x-scalar-watch-mode': optional(boolean({ typeComment: 'Whether the document is in watch mode' })),
+}, {
+    typeName: 'XScalarWatchMode',
+    typeComment: 'Whether the document is in watch mode',
+});

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

@@ -1,7 +1,10 @@
-export declare const XTags: import("@scalar/typebox").TObject<{
+export declare const XTagsSchema: import("@scalar/typebox").TObject<{
     'x-tags': import("@scalar/typebox").TOptional<import("@scalar/typebox").TArray<import("@scalar/typebox").TString>>;
 }>;
 export type XTags = {
     'x-tags'?: string[];
 };
+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/schemas/extensions/document/x-tags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-tags.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-tags.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;EAEhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA"}
+{"version":3,"file":"x-tags.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/document/x-tags.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW;;EAEtB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,KAAK;;EAQjB,CAAA"}

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

@@ -1,4 +1,11 @@
 import { Type } from '@scalar/typebox';
-export const XTags = Type.Object({
+import { array, object, optional, string } from '@scalar/validation';
+export const XTagsSchema = Type.Object({
     'x-tags': Type.Optional(Type.Array(Type.String())),
 });
+export const XTags = object({
+    'x-tags': optional(array(string())),
+}, {
+    typeName: 'XTags',
+    typeComment: 'Custom tag ordering or grouping hints for schema objects',
+});

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

@@ -12,7 +12,13 @@
  * x-disabled: false  # Send this parameter example in the request
  * ```
  */
-export declare const XDisabled: import("@scalar/typebox").TObject<{
+export declare const XDisabledSchema: import("@scalar/typebox").TObject<{
     'x-disabled': import("@scalar/typebox").TOptional<import("@scalar/typebox").TBoolean>;
 }>;
+export type XDisabled = {
+    'x-disabled'?: boolean;
+};
+export declare const XDisabled: import("@scalar/validation").ObjectSchema<{
+    'x-disabled': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>;
 //# sourceMappingURL=x-disabled.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-disabled.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/example/x-disabled.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS;;EAEpB,CAAA"}
+{"version":3,"file":"x-disabled.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/example/x-disabled.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;EAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,SAAS;;EAQrB,CAAA"}

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

@@ -1,4 +1,5 @@
 import { Type } from '@scalar/typebox';
+import { boolean, object, optional } from '@scalar/validation';
 /**
  * OpenAPI extension to control whether a parameter example is enabled (checkbox on) or disabled (checkbox off).
  *
@@ -13,6 +14,12 @@ import { Type } from '@scalar/typebox';
  * x-disabled: false  # Send this parameter example in the request
  * ```
  */
-export const XDisabled = Type.Object({
+export const XDisabledSchema = Type.Object({
     'x-disabled': Type.Optional(Type.Boolean()),
 });
+export const XDisabled = object({
+    'x-disabled': optional(boolean()),
+}, {
+    typeName: 'XDisabled',
+    typeComment: 'Whether a parameter example is disabled in the API client',
+});

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

@@ -5,4 +5,7 @@ export type XScalarActiveEnvironment = {
     /** The currently selected environment */
     'x-scalar-active-environment'?: string;
 };
+export declare const XScalarActiveEnvironment: import("@scalar/validation").ObjectSchema<{
+    'x-scalar-active-environment': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
 //# sourceMappingURL=x-scalar-active-environment.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"x-scalar-active-environment.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/general/x-scalar-active-environment.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B;;EAEzC,CAAA;AAGF,MAAM,MAAM,wBAAwB,GAAG;IACrC,yCAAyC;IACzC,6BAA6B,CAAC,EAAE,MAAM,CAAA;CACvC,CAAA"}
+{"version":3,"file":"x-scalar-active-environment.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/general/x-scalar-active-environment.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,8BAA8B;;EAEzC,CAAA;AAGF,MAAM,MAAM,wBAAwB,GAAG;IACrC,yCAAyC;IACzC,6BAA6B,CAAC,EAAE,MAAM,CAAA;CACvC,CAAA;AAED,eAAO,MAAM,wBAAwB;;EAQpC,CAAA"}