@scalar/workspace-store 0.15.8 → 0.16.2

package/dist/schemas/workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/schemas/workspace.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOrC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE1E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIxB,wFAAwF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI3F,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA"}
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/schemas/workspace.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOrC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,qCAAqC,CAAC,EAAE,+BAA+B,CAAA;IACvE,gCAAgC,CAAC,EAAE,0BAA0B,CAAA;IAC7D,gCAAgC,CAAC,EAAE,YAAY,EAAE,CAAA;IACjD,yCAAyC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;CACjF,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIxB,wFAAwF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI3F,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG;IACtC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC5C,cAAc,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAC9C,GAAG,mBAAmB,CAAA"}

package/dist/schemas/workspace.js

@@ -2,9 +2,17 @@ import { Type } from "@scalar/typebox";
 import { AVAILABLE_CLIENTS } from "@scalar/types/snippetz";
 import { compose } from "../schemas/compose.js";
 import { extensions } from "../schemas/extensions.js";
-import { xScalarClientConfigCookiesSchema } from "../schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-cookies.js";
-import { xScalarClientConfigEnvironmentsSchema } from "../schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-environments.js";
-import { OpenAPIDocumentSchema, SecuritySchemeObjectSchema, ServerObjectSchema } from "./v3.1/strict/openapi-document.js";
+import {
+  xScalarClientConfigCookiesSchema
+} from "../schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-cookies.js";
+import {
+  xScalarClientConfigEnvironmentsSchema
+} from "../schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-environments.js";
+import {
+  OpenAPIDocumentSchema,
+  SecuritySchemeObjectSchema,
+  ServerObjectSchema
+} from "./v3.1/strict/openapi-document.js";
 const WorkspaceDocumentMetaSchema = Type.Partial(
   Type.Object({
     [extensions.document.activeAuth]: Type.String(),

package/dist/schemas/workspace.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/schemas/workspace.ts"],
-  "sourcesContent": ["import { type Static, Type } from '@scalar/typebox'\nimport { AVAILABLE_CLIENTS } from '@scalar/types/snippetz'\n\nimport { compose } from '@/schemas/compose'\nimport { extensions } from '@/schemas/extensions'\nimport { xScalarClientConfigCookiesSchema } from '@/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-cookies'\nimport { xScalarClientConfigEnvironmentsSchema } from '@/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-environments'\n\nimport { OpenAPIDocumentSchema, SecuritySchemeObjectSchema, ServerObjectSchema } from './v3.1/strict/openapi-document'\n\nexport const WorkspaceDocumentMetaSchema = Type.Partial(\n  Type.Object({\n    [extensions.document.activeAuth]: Type.String(),\n    [extensions.document.activeServer]: Type.String(),\n  }),\n)\n\nexport type WorkspaceDocumentMeta = Static<typeof WorkspaceDocumentMetaSchema>\n\n// Note: use Type.Intersect to combine schemas here because Type.Compose does not work as expected with Modules\nexport const WorkspaceDocumentSchema = Type.Intersect([WorkspaceDocumentMetaSchema, OpenAPIDocumentSchema])\n\nexport type WorkspaceDocument = Static<typeof WorkspaceDocumentSchema>\n\nexport const WorkspaceMetaSchema = Type.Partial(\n  Type.Object({\n    [extensions.workspace.darkMode]: Type.Boolean(),\n    [extensions.workspace.defaultClient]: Type.Union(AVAILABLE_CLIENTS.map((client) => Type.Literal(client))),\n    [extensions.workspace.activeDocument]: Type.String(),\n    [extensions.workspace.theme]: Type.String(),\n  }),\n)\n\nexport type WorkspaceMeta = Static<typeof WorkspaceMetaSchema>\n\nexport const WorkspaceExtensionsSchema = Type.Partial(\n  Type.Object({\n    'x-scalar-client-config-environments': xScalarClientConfigEnvironmentsSchema,\n    'x-scalar-client-config-cookies': xScalarClientConfigCookiesSchema,\n    'x-scalar-client-config-servers': Type.Array(ServerObjectSchema),\n    'x-scalar-client-config-security-schemes': Type.Record(Type.String(), SecuritySchemeObjectSchema),\n  }),\n)\n\nexport type WorkspaceExtensions = Static<typeof WorkspaceExtensionsSchema>\n\nexport const WorkspaceSchema = compose(\n  WorkspaceMetaSchema,\n  Type.Object({\n    documents: Type.Record(Type.String(), WorkspaceDocumentSchema),\n    /** Active document is possibly undefined if we attempt to lookup with an invalid key */\n    activeDocument: Type.Union([Type.Undefined(), WorkspaceDocumentSchema]),\n  }),\n  WorkspaceExtensionsSchema,\n)\n\nexport type Workspace = Static<typeof WorkspaceSchema>\n"],
-  "mappings": "AAAA,SAAsB,YAAY;AAClC,SAAS,yBAAyB;AAElC,SAAS,eAAe;AACxB,SAAS,kBAAkB;AAC3B,SAAS,wCAAwC;AACjD,SAAS,6CAA6C;AAEtD,SAAS,uBAAuB,4BAA4B,0BAA0B;AAE/E,MAAM,8BAA8B,KAAK;AAAA,EAC9C,KAAK,OAAO;AAAA,IACV,CAAC,WAAW,SAAS,UAAU,GAAG,KAAK,OAAO;AAAA,IAC9C,CAAC,WAAW,SAAS,YAAY,GAAG,KAAK,OAAO;AAAA,EAClD,CAAC;AACH;AAKO,MAAM,0BAA0B,KAAK,UAAU,CAAC,6BAA6B,qBAAqB,CAAC;AAInG,MAAM,sBAAsB,KAAK;AAAA,EACtC,KAAK,OAAO;AAAA,IACV,CAAC,WAAW,UAAU,QAAQ,GAAG,KAAK,QAAQ;AAAA,IAC9C,CAAC,WAAW,UAAU,aAAa,GAAG,KAAK,MAAM,kBAAkB,IAAI,CAAC,WAAW,KAAK,QAAQ,MAAM,CAAC,CAAC;AAAA,IACxG,CAAC,WAAW,UAAU,cAAc,GAAG,KAAK,OAAO;AAAA,IACnD,CAAC,WAAW,UAAU,KAAK,GAAG,KAAK,OAAO;AAAA,EAC5C,CAAC;AACH;AAIO,MAAM,4BAA4B,KAAK;AAAA,EAC5C,KAAK,OAAO;AAAA,IACV,uCAAuC;AAAA,IACvC,kCAAkC;AAAA,IAClC,kCAAkC,KAAK,MAAM,kBAAkB;AAAA,IAC/D,2CAA2C,KAAK,OAAO,KAAK,OAAO,GAAG,0BAA0B;AAAA,EAClG,CAAC;AACH;AAIO,MAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA,KAAK,OAAO;AAAA,IACV,WAAW,KAAK,OAAO,KAAK,OAAO,GAAG,uBAAuB;AAAA;AAAA,IAE7D,gBAAgB,KAAK,MAAM,CAAC,KAAK,UAAU,GAAG,uBAAuB,CAAC;AAAA,EACxE,CAAC;AAAA,EACD;AACF;",
+  "sourcesContent": ["import { Type } from '@scalar/typebox'\nimport { AVAILABLE_CLIENTS, type AvailableClients } from '@scalar/types/snippetz'\n\nimport { compose } from '@/schemas/compose'\nimport { extensions } from '@/schemas/extensions'\nimport {\n  type XScalarClientConfigCookies,\n  xScalarClientConfigCookiesSchema,\n} from '@/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-cookies'\nimport {\n  type XScalarClientConfigEnvironments,\n  xScalarClientConfigEnvironmentsSchema,\n} from '@/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-environments'\nimport type { SecuritySchemeObject } from '@/schemas/v3.1/strict/security-scheme'\nimport type { ServerObject } from '@/schemas/v3.1/strict/server'\n\nimport {\n  OpenAPIDocumentSchema,\n  type OpenApiDocument,\n  SecuritySchemeObjectSchema,\n  ServerObjectSchema,\n} from './v3.1/strict/openapi-document'\n\nexport const WorkspaceDocumentMetaSchema = Type.Partial(\n  Type.Object({\n    [extensions.document.activeAuth]: Type.String(),\n    [extensions.document.activeServer]: Type.String(),\n  }),\n)\n\nexport type WorkspaceDocumentMeta = {\n  [extensions.document.activeAuth]?: string\n  [extensions.document.activeServer]?: string\n}\n\n// Note: use Type.Intersect to combine schemas here because Type.Compose does not work as expected with Modules\nexport const WorkspaceDocumentSchema = Type.Intersect([WorkspaceDocumentMetaSchema, OpenAPIDocumentSchema])\n\nexport type WorkspaceDocument = WorkspaceDocumentMeta & OpenApiDocument\n\nexport const WorkspaceMetaSchema = Type.Partial(\n  Type.Object({\n    [extensions.workspace.darkMode]: Type.Boolean(),\n    [extensions.workspace.defaultClient]: Type.Union(AVAILABLE_CLIENTS.map((client) => Type.Literal(client))),\n    [extensions.workspace.activeDocument]: Type.String(),\n    [extensions.workspace.theme]: Type.String(),\n  }),\n)\n\nexport type WorkspaceMeta = {\n  [extensions.workspace.darkMode]?: boolean\n  [extensions.workspace.defaultClient]?: AvailableClients[number]\n  [extensions.workspace.activeDocument]?: string\n  [extensions.workspace.theme]?: string\n}\n\nexport const WorkspaceExtensionsSchema = Type.Partial(\n  Type.Object({\n    'x-scalar-client-config-environments': xScalarClientConfigEnvironmentsSchema,\n    'x-scalar-client-config-cookies': xScalarClientConfigCookiesSchema,\n    'x-scalar-client-config-servers': Type.Array(ServerObjectSchema),\n    'x-scalar-client-config-security-schemes': Type.Record(Type.String(), SecuritySchemeObjectSchema),\n  }),\n)\n\nexport type WorkspaceExtensions = {\n  'x-scalar-client-config-environments'?: XScalarClientConfigEnvironments\n  'x-scalar-client-config-cookies'?: XScalarClientConfigCookies\n  'x-scalar-client-config-servers'?: ServerObject[]\n  'x-scalar-client-config-security-schemes'?: Record<string, SecuritySchemeObject>\n}\n\nexport const WorkspaceSchema = compose(\n  WorkspaceMetaSchema,\n  Type.Object({\n    documents: Type.Record(Type.String(), WorkspaceDocumentSchema),\n    /** Active document is possibly undefined if we attempt to lookup with an invalid key */\n    activeDocument: Type.Union([Type.Undefined(), WorkspaceDocumentSchema]),\n  }),\n  WorkspaceExtensionsSchema,\n)\n\nexport type Workspace = WorkspaceMeta & {\n  documents: Record<string, WorkspaceDocument>\n  activeDocument: WorkspaceDocument | undefined\n} & WorkspaceExtensions\n"],
+  "mappings": "AAAA,SAAS,YAAY;AACrB,SAAS,yBAAgD;AAEzD,SAAS,eAAe;AACxB,SAAS,kBAAkB;AAC3B;AAAA,EAEE;AAAA,OACK;AACP;AAAA,EAEE;AAAA,OACK;AAIP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AAEA,MAAM,8BAA8B,KAAK;AAAA,EAC9C,KAAK,OAAO;AAAA,IACV,CAAC,WAAW,SAAS,UAAU,GAAG,KAAK,OAAO;AAAA,IAC9C,CAAC,WAAW,SAAS,YAAY,GAAG,KAAK,OAAO;AAAA,EAClD,CAAC;AACH;AAQO,MAAM,0BAA0B,KAAK,UAAU,CAAC,6BAA6B,qBAAqB,CAAC;AAInG,MAAM,sBAAsB,KAAK;AAAA,EACtC,KAAK,OAAO;AAAA,IACV,CAAC,WAAW,UAAU,QAAQ,GAAG,KAAK,QAAQ;AAAA,IAC9C,CAAC,WAAW,UAAU,aAAa,GAAG,KAAK,MAAM,kBAAkB,IAAI,CAAC,WAAW,KAAK,QAAQ,MAAM,CAAC,CAAC;AAAA,IACxG,CAAC,WAAW,UAAU,cAAc,GAAG,KAAK,OAAO;AAAA,IACnD,CAAC,WAAW,UAAU,KAAK,GAAG,KAAK,OAAO;AAAA,EAC5C,CAAC;AACH;AASO,MAAM,4BAA4B,KAAK;AAAA,EAC5C,KAAK,OAAO;AAAA,IACV,uCAAuC;AAAA,IACvC,kCAAkC;AAAA,IAClC,kCAAkC,KAAK,MAAM,kBAAkB;AAAA,IAC/D,2CAA2C,KAAK,OAAO,KAAK,OAAO,GAAG,0BAA0B;AAAA,EAClG,CAAC;AACH;AASO,MAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA,KAAK,OAAO;AAAA,IACV,WAAW,KAAK,OAAO,KAAK,OAAO,GAAG,uBAAuB;AAAA;AAAA,IAE7D,gBAAgB,KAAK,MAAM,CAAC,KAAK,UAAU,GAAG,uBAAuB,CAAC;AAAA,EACxE,CAAC;AAAA,EACD;AACF;",
   "names": []
 }

package/dist/server.d.ts

@@ -1,5 +1,6 @@
 import { extensions } from './schemas/extensions.js';
-import { type OpenApiDocument, type OperationObject, type PathsObject, type TraversedEntry } from './schemas/v3.1/strict/openapi-document.js';
+import type { TraversedEntry } from './schemas/navigation.js';
+import { type OpenApiDocument, type OperationObject, type PathsObject } from './schemas/v3.1/strict/openapi-document.js';
 import type { DocumentConfiguration } from './schemas/workspace-specification/config.js';
 import type { WorkspaceDocumentMeta, WorkspaceMeta } from './schemas/workspace.js';
 export declare const WORKSPACE_FILE_NAME = "scalar-workspace.json";
@@ -118,10 +119,10 @@ export declare function createServerWorkspaceStore(workspaceProps: CreateServerW
         documents: Record<string, OpenApiDocument & {
             [extensions.document.navigation]: TraversedEntry[];
         }>;
-        "x-scalar-dark-mode"?: boolean | undefined;
-        "x-scalar-default-client"?: "c/libcurl" | "clojure/clj_http" | "csharp/httpclient" | "csharp/restsharp" | "dart/http" | "go/native" | "http/http1.1" | "java/asynchttp" | "java/nethttp" | "java/okhttp" | "java/unirest" | "js/axios" | "js/fetch" | "js/jquery" | "js/ofetch" | "js/xhr" | "kotlin/okhttp" | "node/axios" | "node/fetch" | "node/ofetch" | "node/undici" | "objc/nsurlsession" | "ocaml/cohttp" | "php/curl" | "php/guzzle" | "powershell/restmethod" | "powershell/webrequest" | "python/python3" | "python/requests" | "python/httpx_sync" | "python/httpx_async" | "r/httr" | "ruby/native" | "rust/reqwest" | "shell/curl" | "shell/httpie" | "shell/wget" | "swift/nsurlsession" | undefined;
-        "x-scalar-active-document"?: string | undefined;
-        "x-scalar-theme"?: string | undefined;
+        "x-scalar-dark-mode"?: boolean;
+        "x-scalar-default-client"?: import("@scalar/snippetz").AvailableClients[number];
+        "x-scalar-active-document"?: string;
+        "x-scalar-theme"?: string;
     };
     /**
      * Retrieves a chunk of data from the workspace using a JSON Pointer

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/server.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/server.ts"],
-  "sourcesContent": ["import fs from 'node:fs/promises'\nimport { cwd } from 'node:process'\n\nimport { fetchUrls, readFiles } from '@scalar/json-magic/bundle/plugins/node'\nimport { escapeJsonPointer } from '@scalar/json-magic/helpers/escape-json-pointer'\nimport { upgrade } from '@scalar/openapi-upgrader'\n\nimport { keyOf } from '@/helpers/general'\nimport { createNavigation } from '@/navigation'\nimport { extensions } from '@/schemas/extensions'\nimport { coerceValue } from '@/schemas/typebox-coerce'\nimport {\n  type ComponentsObject,\n  OpenAPIDocumentSchema,\n  type OpenApiDocument,\n  type OperationObject,\n  type PathsObject,\n  type TraversedEntry,\n} from '@/schemas/v3.1/strict/openapi-document'\nimport type { DocumentConfiguration } from '@/schemas/workspace-specification/config'\n\nimport { getValueByPath, parseJsonPointer } from './helpers/json-path-utils'\nimport type { WorkspaceDocumentMeta, WorkspaceMeta } from './schemas/workspace'\n\nconst DEFAULT_ASSETS_FOLDER = 'assets'\nexport const WORKSPACE_FILE_NAME = 'scalar-workspace.json'\n\ntype WorkspaceDocumentMetaInput = {\n  name: string\n  meta?: WorkspaceDocumentMeta\n}\n\ntype UrlDoc = { url: string } & WorkspaceDocumentMetaInput\ntype FileDoc = { path: string } & WorkspaceDocumentMetaInput\ntype ObjectDoc = { document: Record<string, unknown> } & WorkspaceDocumentMetaInput\n\ntype WorkspaceDocumentInput = UrlDoc | ObjectDoc | FileDoc\n\ntype CreateServerWorkspaceStoreBase = {\n  documents: WorkspaceDocumentInput[]\n  meta?: WorkspaceMeta\n  config?: DocumentConfiguration\n}\ntype CreateServerWorkspaceStore =\n  | ({\n      directory?: string\n      mode: 'static'\n    } & CreateServerWorkspaceStoreBase)\n  | ({\n      baseUrl: string\n      mode: 'ssr'\n    } & CreateServerWorkspaceStoreBase)\n\nconst httpMethods = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'])\n\n/**\n * Filters an OpenAPI PathsObject to only include standard HTTP methods.\n * Removes any vendor extensions or other non-HTTP properties.\n *\n * @param paths - The OpenAPI PathsObject to filter\n * @returns A new PathsObject containing only standard HTTP methods\n *\n * @example\n * Input: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"x-custom\": {...},\n *     \"post\": {...}\n *   }\n * }\n * Output: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"post\": {...}\n *   }\n * }\n */\nexport function filterHttpMethodsOnly(paths: PathsObject): Record<string, Record<string, OperationObject>> {\n  const result: Record<string, Record<string, OperationObject>> = {}\n\n  // Todo: skip extension properties\n  for (const [path, methods] of Object.entries(paths)) {\n    if (!methods) {\n      continue\n    }\n\n    const filteredMethods: Record<string, any> = {}\n\n    for (const [method, operation] of Object.entries(methods)) {\n      if (httpMethods.has(method.toLowerCase())) {\n        filteredMethods[method] = operation\n      }\n    }\n\n    if (Object.keys(filteredMethods).length > 0) {\n      result[path] = filteredMethods\n    }\n  }\n\n  return result\n}\n\n/**\n * Escapes path keys in an OpenAPI PathsObject to be JSON Pointer compatible.\n * This is necessary because OpenAPI paths can contain characters that need to be escaped\n * when used as JSON Pointer references (like '/' and '~').\n *\n * @example\n * Input: { \"/users/{id}\": { ... } }\n * Output: { \"/users~1{id}\": { ... } }\n */\nexport function escapePaths(\n  paths: Record<string, Record<string, OperationObject>>,\n): Record<string, Record<string, OperationObject>> {\n  const result: Record<string, Record<string, OperationObject>> = {}\n\n  Object.keys(paths).forEach((path) => {\n    if (paths[path]) {\n      result[escapeJsonPointer(path)] = paths[path]\n    }\n  })\n\n  return result\n}\n\n/**\n * Externalizes components by turning them into refs.\n */\nexport function externalizeComponentReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.components) {\n    return result\n  }\n\n  Object.entries(document.components).forEach(([type, component]) => {\n    if (!component || typeof component !== 'object') {\n      return\n    }\n\n    result[type] = {}\n    Object.keys(component).forEach((name) => {\n      const ref =\n        meta.mode === 'ssr'\n          ? `${meta.baseUrl}/${meta.name}/components/${type}/${name}#`\n          : `./chunks/${meta.name}/components/${type}/${name}.json#`\n\n      result[type][name] = { '$ref': ref, $global: true }\n    })\n  })\n\n  return result\n}\n\n/**\n * Externalizes paths operations by turning them into refs.\n */\nexport function externalizePathReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.paths) {\n    return result\n  }\n\n  Object.entries(document.paths).forEach(([path, pathItem]) => {\n    if (!pathItem || typeof pathItem !== 'object') {\n      return\n    }\n\n    const pathItemRecord = pathItem as Record<string, unknown>\n\n    result[path] = {}\n\n    const escapedPath = escapeJsonPointer(path)\n\n    keyOf(pathItemRecord).forEach((type) => {\n      if (httpMethods.has(type)) {\n        const ref =\n          meta.mode === 'ssr'\n            ? `${meta.baseUrl}/${meta.name}/operations/${escapedPath}/${type}#`\n            : `./chunks/${meta.name}/operations/${escapedPath}/${type}.json#`\n\n        result[path][type] = { '$ref': ref, $global: true }\n      } else {\n        result[path][type] = pathItemRecord[type]\n      }\n    })\n  })\n\n  return result\n}\n\n/**\n * Resolves a workspace document from various input sources (URL, local file, or direct document object).\n *\n * @param workspaceDocument - The document input to resolve, which can be:\n *   - A URL to fetch the document from\n *   - A local file path to read the document from\n *   - A direct document object\n * @returns A promise that resolves to an object containing:\n *   - ok: boolean indicating if the resolution was successful\n *   - data: The resolved document data\n *\n * @example\n * // Resolve from URL\n * const urlDoc = await loadDocument({ name: 'api', url: 'https://api.example.com/openapi.json' })\n *\n * // Resolve direct document\n * const directDoc = await loadDocument({\n *   name: 'inline',\n *   document: { openapi: '3.0.0', paths: {} }\n * })\n */\nasync function loadDocument(workspaceDocument: WorkspaceDocumentInput) {\n  if ('url' in workspaceDocument) {\n    return fetchUrls().exec(workspaceDocument.url)\n  }\n\n  if ('path' in workspaceDocument) {\n    return readFiles().exec(workspaceDocument.path)\n  }\n\n  return {\n    ok: true as const,\n    data: workspaceDocument.document,\n  }\n}\n\n/**\n * Create server state workspace store\n */\nexport async function createServerWorkspaceStore(workspaceProps: CreateServerWorkspaceStore) {\n  /**\n   * Base workspace document containing essential metadata and document references.\n   *\n   * This workspace document provides the minimal information needed for initial rendering.\n   * All components and path operations are replaced with references to enable lazy loading.\n   *\n   * In SSR mode, references point to API endpoints.\n   * In static mode, references point to filesystem chunks.\n   */\n  const workspace = {\n    ...workspaceProps.meta,\n    documents: {} as Record<string, OpenApiDocument & { [extensions.document.navigation]: TraversedEntry[] }>,\n  }\n\n  /**\n   * A map of document chunks that can be loaded asynchronously by the client.\n   * Each document is split into components and operations to enable lazy loading.\n   * The keys are document names and values contain the components and operations\n   * for that document.\n   */\n  const assets = {} as Record<\n    string,\n    { components?: ComponentsObject; operations?: Record<string, Record<string, OperationObject>> }\n  >\n\n  /**\n   * Adds a new document to the workspace.\n   *\n   * This function processes an OpenAPI document by:\n   * 1. Converting it to OpenAPI 3.1 format if needed\n   * 2. Separating it into reusable components and path operations\n   * 3. Externalizing references based on the workspace mode (SSR or static)\n   * 4. Adding the processed document to the workspace with its metadata\n   *\n   * The resulting document contains minimal information with externalized references\n   * that will be resolved on-demand through the workspace's get() method.\n   *\n   * @param document - The OpenAPI document to process and add\n   * @param meta - Document metadata containing the required name and optional settings\n   */\n  const addDocumentSync = (document: Record<string, unknown>, meta: { name: string } & WorkspaceDocumentMeta) => {\n    const { name, ...documentMeta } = meta\n\n    const documentV3 = coerceValue(OpenAPIDocumentSchema, upgrade(document, '3.1'))\n\n    // add the assets\n    assets[meta.name] = {\n      components: documentV3.components,\n      operations: documentV3.paths && escapePaths(filterHttpMethodsOnly(documentV3.paths)),\n    }\n\n    const options =\n      workspaceProps.mode === 'ssr'\n        ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl }\n        : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER }\n\n    const components = externalizeComponentReferences(documentV3, options)\n    const paths = externalizePathReferences(documentV3, options)\n\n    // Build the sidebar entries\n    const { entries } = createNavigation(documentV3, workspaceProps.config ?? {})\n\n    // The document is now a minimal version with externalized references to components and operations.\n    // These references will be resolved asynchronously when needed through the workspace's get() method.\n    workspace.documents[meta.name] = {\n      ...documentMeta,\n      ...documentV3,\n      components,\n      paths,\n      [extensions.document.navigation]: entries,\n    }\n  }\n\n  /**\n   * Adds a new document to the workspace asynchronously.\n   *\n   * This function:\n   * 1. Loads the document using the provided input\n   * 2. Checks if the document loaded successfully\n   * 3. If successful, adds the document to the workspace using addDocumentSync\n   *\n   * @param input - The document input containing the document source and metadata\n   */\n  const addDocument = async (input: WorkspaceDocumentInput) => {\n    const document = await loadDocument(input)\n\n    if (!document.ok) {\n      console.warn(`Failed to load document \"${input.name}`)\n      return\n    }\n\n    addDocumentSync(document.data as Record<string, unknown>, { name: input.name, ...input.meta })\n  }\n\n  // Load and process all initial documents in parallel\n  await Promise.all(workspaceProps.documents.map(addDocument))\n\n  return {\n    /**\n     * Generates workspace chunks by writing components and operations to the filesystem.\n     *\n     * This method is only available in static mode. It creates a directory structure containing:\n     * - A workspace file with metadata and document references\n     * - Component chunks split by type (schemas, parameters, etc)\n     * - Operation chunks split by path and HTTP method\n     *\n     * The generated workspace references will be relative file paths pointing to these chunks.\n     *\n     * @throws {Error} If called when mode is not 'static'\n     */\n    generateWorkspaceChunks: async () => {\n      if (workspaceProps.mode !== 'static') {\n        throw 'Mode has to be set to `static` to generate filesystem workspace chunks'\n      }\n\n      // Write the workspace document\n      const basePath = `${cwd()}/${workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER}`\n      await fs.mkdir(basePath, { recursive: true })\n\n      // Write the workspace contents on the file system\n      await fs.writeFile(`${basePath}/${WORKSPACE_FILE_NAME}`, JSON.stringify(workspace))\n\n      // Write the chunks\n      for (const [name, { components, operations }] of Object.entries(assets)) {\n        // Write the components chunks\n        if (components) {\n          for (const [type, component] of Object.entries(components as Record<string, Record<string, unknown>>)) {\n            const componentPath = `${basePath}/chunks/${name}/components/${type}`\n            await fs.mkdir(componentPath, { recursive: true })\n\n            for (const [key, value] of Object.entries(component)) {\n              await fs.writeFile(`${componentPath}/${key}.json`, JSON.stringify(value))\n            }\n          }\n        }\n\n        // Write the operations chunks\n        if (operations) {\n          for (const [path, methods] of Object.entries(operations)) {\n            const operationPath = `${basePath}/chunks/${name}/operations/${path}`\n            await fs.mkdir(operationPath, { recursive: true })\n\n            for (const [method, operation] of Object.entries(methods)) {\n              await fs.writeFile(`${operationPath}/${method}.json`, JSON.stringify(operation))\n            }\n          }\n        }\n      }\n    },\n    /**\n     * Returns the workspace document containing metadata and all sparse documents.\n     *\n     * The workspace document includes:\n     * - Global workspace metadata (theme, active document, etc)\n     * - Document metadata and sparse document\n     * - In SSR mode: References point to in-memory chunks\n     * - In static mode: References point to filesystem chunks\n     *\n     * @returns The complete workspace document\n     */\n    getWorkspace: () => {\n      return workspace\n    },\n    /**\n     * Retrieves a chunk of data from the workspace using a JSON Pointer\n     *\n     * A JSON Pointer is a string that references a specific location in a JSON document.\n     * Only components and operations chunks can be retrieved.\n     *\n     * @example\n     * ```ts\n     * // Get a component\n     * get('#/document-name/components/schemas/User')\n     *\n     * // Get an operation\n     * get('#/document-name/operations/pets/get')\n     * ```\n     *\n     * @param pointer - The JSON Pointer string to locate the chunk\n     * @returns The chunk data if found, undefined otherwise\n     */\n    get: (pointer: string) => {\n      return getValueByPath(assets, parseJsonPointer(pointer))\n    },\n    /**\n     * Adds a new document to the workspace asynchronously.\n     *\n     * This function:\n     * 1. Loads the document using the provided input\n     * 2. Checks if the document loaded successfully\n     * 3. If successful, adds the document to the workspace using addDocumentSync\n     *\n     * @param input - The document input containing the document source and metadata\n     */\n    addDocument,\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import fs from 'node:fs/promises'\nimport { cwd } from 'node:process'\n\nimport { fetchUrls, readFiles } from '@scalar/json-magic/bundle/plugins/node'\nimport { escapeJsonPointer } from '@scalar/json-magic/helpers/escape-json-pointer'\nimport { upgrade } from '@scalar/openapi-upgrader'\n\nimport { keyOf } from '@/helpers/general'\nimport { createNavigation } from '@/navigation'\nimport { extensions } from '@/schemas/extensions'\nimport type { TraversedEntry } from '@/schemas/navigation'\nimport { coerceValue } from '@/schemas/typebox-coerce'\nimport {\n  type ComponentsObject,\n  OpenAPIDocumentSchema,\n  type OpenApiDocument,\n  type OperationObject,\n  type PathsObject,\n} from '@/schemas/v3.1/strict/openapi-document'\nimport type { DocumentConfiguration } from '@/schemas/workspace-specification/config'\n\nimport { getValueByPath, parseJsonPointer } from './helpers/json-path-utils'\nimport type { WorkspaceDocumentMeta, WorkspaceMeta } from './schemas/workspace'\n\nconst DEFAULT_ASSETS_FOLDER = 'assets'\nexport const WORKSPACE_FILE_NAME = 'scalar-workspace.json'\n\ntype WorkspaceDocumentMetaInput = {\n  name: string\n  meta?: WorkspaceDocumentMeta\n}\n\ntype UrlDoc = { url: string } & WorkspaceDocumentMetaInput\ntype FileDoc = { path: string } & WorkspaceDocumentMetaInput\ntype ObjectDoc = { document: Record<string, unknown> } & WorkspaceDocumentMetaInput\n\ntype WorkspaceDocumentInput = UrlDoc | ObjectDoc | FileDoc\n\ntype CreateServerWorkspaceStoreBase = {\n  documents: WorkspaceDocumentInput[]\n  meta?: WorkspaceMeta\n  config?: DocumentConfiguration\n}\ntype CreateServerWorkspaceStore =\n  | ({\n      directory?: string\n      mode: 'static'\n    } & CreateServerWorkspaceStoreBase)\n  | ({\n      baseUrl: string\n      mode: 'ssr'\n    } & CreateServerWorkspaceStoreBase)\n\nconst httpMethods = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'])\n\n/**\n * Filters an OpenAPI PathsObject to only include standard HTTP methods.\n * Removes any vendor extensions or other non-HTTP properties.\n *\n * @param paths - The OpenAPI PathsObject to filter\n * @returns A new PathsObject containing only standard HTTP methods\n *\n * @example\n * Input: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"x-custom\": {...},\n *     \"post\": {...}\n *   }\n * }\n * Output: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"post\": {...}\n *   }\n * }\n */\nexport function filterHttpMethodsOnly(paths: PathsObject): Record<string, Record<string, OperationObject>> {\n  const result: Record<string, Record<string, OperationObject>> = {}\n\n  // Todo: skip extension properties\n  for (const [path, methods] of Object.entries(paths)) {\n    if (!methods) {\n      continue\n    }\n\n    const filteredMethods: Record<string, any> = {}\n\n    for (const [method, operation] of Object.entries(methods)) {\n      if (httpMethods.has(method.toLowerCase())) {\n        filteredMethods[method] = operation\n      }\n    }\n\n    if (Object.keys(filteredMethods).length > 0) {\n      result[path] = filteredMethods\n    }\n  }\n\n  return result\n}\n\n/**\n * Escapes path keys in an OpenAPI PathsObject to be JSON Pointer compatible.\n * This is necessary because OpenAPI paths can contain characters that need to be escaped\n * when used as JSON Pointer references (like '/' and '~').\n *\n * @example\n * Input: { \"/users/{id}\": { ... } }\n * Output: { \"/users~1{id}\": { ... } }\n */\nexport function escapePaths(\n  paths: Record<string, Record<string, OperationObject>>,\n): Record<string, Record<string, OperationObject>> {\n  const result: Record<string, Record<string, OperationObject>> = {}\n\n  Object.keys(paths).forEach((path) => {\n    if (paths[path]) {\n      result[escapeJsonPointer(path)] = paths[path]\n    }\n  })\n\n  return result\n}\n\n/**\n * Externalizes components by turning them into refs.\n */\nexport function externalizeComponentReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.components) {\n    return result\n  }\n\n  Object.entries(document.components).forEach(([type, component]) => {\n    if (!component || typeof component !== 'object') {\n      return\n    }\n\n    result[type] = {}\n    Object.keys(component).forEach((name) => {\n      const ref =\n        meta.mode === 'ssr'\n          ? `${meta.baseUrl}/${meta.name}/components/${type}/${name}#`\n          : `./chunks/${meta.name}/components/${type}/${name}.json#`\n\n      result[type][name] = { '$ref': ref, $global: true }\n    })\n  })\n\n  return result\n}\n\n/**\n * Externalizes paths operations by turning them into refs.\n */\nexport function externalizePathReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.paths) {\n    return result\n  }\n\n  Object.entries(document.paths).forEach(([path, pathItem]) => {\n    if (!pathItem || typeof pathItem !== 'object') {\n      return\n    }\n\n    const pathItemRecord = pathItem as Record<string, unknown>\n\n    result[path] = {}\n\n    const escapedPath = escapeJsonPointer(path)\n\n    keyOf(pathItemRecord).forEach((type) => {\n      if (httpMethods.has(type)) {\n        const ref =\n          meta.mode === 'ssr'\n            ? `${meta.baseUrl}/${meta.name}/operations/${escapedPath}/${type}#`\n            : `./chunks/${meta.name}/operations/${escapedPath}/${type}.json#`\n\n        result[path][type] = { '$ref': ref, $global: true }\n      } else {\n        result[path][type] = pathItemRecord[type]\n      }\n    })\n  })\n\n  return result\n}\n\n/**\n * Resolves a workspace document from various input sources (URL, local file, or direct document object).\n *\n * @param workspaceDocument - The document input to resolve, which can be:\n *   - A URL to fetch the document from\n *   - A local file path to read the document from\n *   - A direct document object\n * @returns A promise that resolves to an object containing:\n *   - ok: boolean indicating if the resolution was successful\n *   - data: The resolved document data\n *\n * @example\n * // Resolve from URL\n * const urlDoc = await loadDocument({ name: 'api', url: 'https://api.example.com/openapi.json' })\n *\n * // Resolve direct document\n * const directDoc = await loadDocument({\n *   name: 'inline',\n *   document: { openapi: '3.0.0', paths: {} }\n * })\n */\nasync function loadDocument(workspaceDocument: WorkspaceDocumentInput) {\n  if ('url' in workspaceDocument) {\n    return fetchUrls().exec(workspaceDocument.url)\n  }\n\n  if ('path' in workspaceDocument) {\n    return readFiles().exec(workspaceDocument.path)\n  }\n\n  return {\n    ok: true as const,\n    data: workspaceDocument.document,\n  }\n}\n\n/**\n * Create server state workspace store\n */\nexport async function createServerWorkspaceStore(workspaceProps: CreateServerWorkspaceStore) {\n  /**\n   * Base workspace document containing essential metadata and document references.\n   *\n   * This workspace document provides the minimal information needed for initial rendering.\n   * All components and path operations are replaced with references to enable lazy loading.\n   *\n   * In SSR mode, references point to API endpoints.\n   * In static mode, references point to filesystem chunks.\n   */\n  const workspace = {\n    ...workspaceProps.meta,\n    documents: {} as Record<string, OpenApiDocument & { [extensions.document.navigation]: TraversedEntry[] }>,\n  }\n\n  /**\n   * A map of document chunks that can be loaded asynchronously by the client.\n   * Each document is split into components and operations to enable lazy loading.\n   * The keys are document names and values contain the components and operations\n   * for that document.\n   */\n  const assets = {} as Record<\n    string,\n    { components?: ComponentsObject; operations?: Record<string, Record<string, OperationObject>> }\n  >\n\n  /**\n   * Adds a new document to the workspace.\n   *\n   * This function processes an OpenAPI document by:\n   * 1. Converting it to OpenAPI 3.1 format if needed\n   * 2. Separating it into reusable components and path operations\n   * 3. Externalizing references based on the workspace mode (SSR or static)\n   * 4. Adding the processed document to the workspace with its metadata\n   *\n   * The resulting document contains minimal information with externalized references\n   * that will be resolved on-demand through the workspace's get() method.\n   *\n   * @param document - The OpenAPI document to process and add\n   * @param meta - Document metadata containing the required name and optional settings\n   */\n  const addDocumentSync = (document: Record<string, unknown>, meta: { name: string } & WorkspaceDocumentMeta) => {\n    const { name, ...documentMeta } = meta\n\n    const documentV3 = coerceValue(OpenAPIDocumentSchema, upgrade(document, '3.1'))\n\n    // add the assets\n    assets[meta.name] = {\n      components: documentV3.components,\n      operations: documentV3.paths && escapePaths(filterHttpMethodsOnly(documentV3.paths)),\n    }\n\n    const options =\n      workspaceProps.mode === 'ssr'\n        ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl }\n        : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER }\n\n    const components = externalizeComponentReferences(documentV3, options)\n    const paths = externalizePathReferences(documentV3, options)\n\n    // Build the sidebar entries\n    const { entries } = createNavigation(documentV3, workspaceProps.config ?? {})\n\n    // The document is now a minimal version with externalized references to components and operations.\n    // These references will be resolved asynchronously when needed through the workspace's get() method.\n    workspace.documents[meta.name] = {\n      ...documentMeta,\n      ...documentV3,\n      components,\n      paths,\n      [extensions.document.navigation]: entries,\n    }\n  }\n\n  /**\n   * Adds a new document to the workspace asynchronously.\n   *\n   * This function:\n   * 1. Loads the document using the provided input\n   * 2. Checks if the document loaded successfully\n   * 3. If successful, adds the document to the workspace using addDocumentSync\n   *\n   * @param input - The document input containing the document source and metadata\n   */\n  const addDocument = async (input: WorkspaceDocumentInput) => {\n    const document = await loadDocument(input)\n\n    if (!document.ok) {\n      console.warn(`Failed to load document \"${input.name}`)\n      return\n    }\n\n    addDocumentSync(document.data as Record<string, unknown>, { name: input.name, ...input.meta })\n  }\n\n  // Load and process all initial documents in parallel\n  await Promise.all(workspaceProps.documents.map(addDocument))\n\n  return {\n    /**\n     * Generates workspace chunks by writing components and operations to the filesystem.\n     *\n     * This method is only available in static mode. It creates a directory structure containing:\n     * - A workspace file with metadata and document references\n     * - Component chunks split by type (schemas, parameters, etc)\n     * - Operation chunks split by path and HTTP method\n     *\n     * The generated workspace references will be relative file paths pointing to these chunks.\n     *\n     * @throws {Error} If called when mode is not 'static'\n     */\n    generateWorkspaceChunks: async () => {\n      if (workspaceProps.mode !== 'static') {\n        throw 'Mode has to be set to `static` to generate filesystem workspace chunks'\n      }\n\n      // Write the workspace document\n      const basePath = `${cwd()}/${workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER}`\n      await fs.mkdir(basePath, { recursive: true })\n\n      // Write the workspace contents on the file system\n      await fs.writeFile(`${basePath}/${WORKSPACE_FILE_NAME}`, JSON.stringify(workspace))\n\n      // Write the chunks\n      for (const [name, { components, operations }] of Object.entries(assets)) {\n        // Write the components chunks\n        if (components) {\n          for (const [type, component] of Object.entries(components as Record<string, Record<string, unknown>>)) {\n            const componentPath = `${basePath}/chunks/${name}/components/${type}`\n            await fs.mkdir(componentPath, { recursive: true })\n\n            for (const [key, value] of Object.entries(component)) {\n              await fs.writeFile(`${componentPath}/${key}.json`, JSON.stringify(value))\n            }\n          }\n        }\n\n        // Write the operations chunks\n        if (operations) {\n          for (const [path, methods] of Object.entries(operations)) {\n            const operationPath = `${basePath}/chunks/${name}/operations/${path}`\n            await fs.mkdir(operationPath, { recursive: true })\n\n            for (const [method, operation] of Object.entries(methods)) {\n              await fs.writeFile(`${operationPath}/${method}.json`, JSON.stringify(operation))\n            }\n          }\n        }\n      }\n    },\n    /**\n     * Returns the workspace document containing metadata and all sparse documents.\n     *\n     * The workspace document includes:\n     * - Global workspace metadata (theme, active document, etc)\n     * - Document metadata and sparse document\n     * - In SSR mode: References point to in-memory chunks\n     * - In static mode: References point to filesystem chunks\n     *\n     * @returns The complete workspace document\n     */\n    getWorkspace: () => {\n      return workspace\n    },\n    /**\n     * Retrieves a chunk of data from the workspace using a JSON Pointer\n     *\n     * A JSON Pointer is a string that references a specific location in a JSON document.\n     * Only components and operations chunks can be retrieved.\n     *\n     * @example\n     * ```ts\n     * // Get a component\n     * get('#/document-name/components/schemas/User')\n     *\n     * // Get an operation\n     * get('#/document-name/operations/pets/get')\n     * ```\n     *\n     * @param pointer - The JSON Pointer string to locate the chunk\n     * @returns The chunk data if found, undefined otherwise\n     */\n    get: (pointer: string) => {\n      return getValueByPath(assets, parseJsonPointer(pointer))\n    },\n    /**\n     * Adds a new document to the workspace asynchronously.\n     *\n     * This function:\n     * 1. Loads the document using the provided input\n     * 2. Checks if the document loaded successfully\n     * 3. If successful, adds the document to the workspace using addDocumentSync\n     *\n     * @param input - The document input containing the document source and metadata\n     */\n    addDocument,\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/package.json

@@ -16,7 +16,7 @@
     "openapi",
     "scalar"
   ],
-  "version": "0.15.8",
+  "version": "0.16.2",
   "engines": {
     "node": ">=18"
   },
@@ -47,21 +47,16 @@
       "types": "./dist/helpers/*.d.ts",
       "default": "./dist/helpers/*.js"
     },
-    "./schemas/extensions/*": {
-      "import": "./dist/schemas/extensions/*.js",
-      "types": "./dist/schemas/extensions/*.d.ts",
-      "default": "./dist/schemas/extensions/*.js"
+    "./schemas/extensions/operation": {
+      "import": "./dist/schemas/extensions/operation/index.js",
+      "types": "./dist/schemas/extensions/operation/index.d.ts",
+      "default": "./dist/schemas/extensions/operation/index.js"
     },
     "./schemas/v3.1/*": {
       "import": "./dist/schemas/v3.1/*.js",
       "types": "./dist/schemas/v3.1/*.d.ts",
       "default": "./dist/schemas/v3.1/*.js"
     },
-    "./schemas/v3.1/strict/*": {
-      "import": "./dist/schemas/v3.1/strict/*.js",
-      "types": "./dist/schemas/v3.1/strict/*.d.ts",
-      "default": "./dist/schemas/v3.1/strict/*.js"
-    },
     "./server": {
       "import": "./dist/server.js",
       "types": "./dist/server.d.ts",
@@ -85,10 +80,10 @@
     "yaml": "2.8.0",
     "@scalar/code-highlight": "0.2.0",
     "@scalar/helpers": "0.0.11",
-    "@scalar/json-magic": "0.5.1",
-    "@scalar/openapi-upgrader": "0.1.0",
-    "@scalar/snippetz": "0.4.10",
-    "@scalar/types": "0.2.16"
+    "@scalar/json-magic": "0.6.0",
+    "@scalar/openapi-upgrader": "0.1.1",
+    "@scalar/types": "0.3.0",
+    "@scalar/snippetz": "0.4.11"
   },
   "devDependencies": {
     "@google-cloud/storage": "7.16.0",

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

@@ -1,21 +0,0 @@
-import type { OperationIdentifier } from '../mutators/request.js';
-import type { WorkspaceDocument } from '../schemas.js';
-import type { XScalarClientConfigRequestExample } from '../schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example.js';
-/**
- * Provides mutator functions for managing request examples within OpenAPI operations.
- * This module contains utilities for adding and deleting request examples that are
- * stored as custom extensions on OpenAPI operations.
- *
- * @param document - The workspace document to operate on
- * @returns Object containing mutator functions for request example operations
- */
-export declare const requestExampleMutators: (document?: WorkspaceDocument) => {
-    addRequestExample: ({ path, method, slug, request, }: OperationIdentifier & {
-        slug: string;
-        request: XScalarClientConfigRequestExample;
-    }) => boolean;
-    deleteRequestExample: ({ path, method, slug }: OperationIdentifier & {
-        slug: string;
-    }) => boolean;
-};
-//# sourceMappingURL=request-example.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"request-example.d.ts","sourceRoot":"","sources":["../../src/mutators/request-example.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,uFAAuF,CAAA;AAE9I;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GAAI,WAAW,iBAAiB;0DA4B9D,mBAAmB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,iCAAiC,CAAA;KAAE;mDA6C/B,mBAAmB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;CA8B7F,CAAA"}

package/dist/mutators/request-example.js

@@ -1,55 +0,0 @@
-import { getResolvedRef } from "../helpers/get-resolved-ref.js";
-const requestExampleMutators = (document) => {
-  const addRequestExample = ({
-    path,
-    method,
-    slug,
-    request
-  }) => {
-    if (!document || !document.paths) {
-      return false;
-    }
-    if (!document.paths[path]) {
-      document.paths[path] = {};
-    }
-    if (!document.paths[path][method]) {
-      document.paths[path][method] = {};
-    }
-    const operation = getResolvedRef(document.paths[path][method]);
-    if (!operation["x-scalar-client-config-request-example"]) {
-      operation["x-scalar-client-config-request-example"] = {};
-    }
-    if (operation["x-scalar-client-config-request-example"][slug]) {
-      console.warn(`Request example with slug "${slug}" already exists for ${method.toUpperCase()} ${path}.`);
-      return false;
-    }
-    operation["x-scalar-client-config-request-example"][slug] = request;
-    return true;
-  };
-  const deleteRequestExample = ({ path, method, slug }) => {
-    if (!document) {
-      return false;
-    }
-    const pathObject = document?.paths?.[path];
-    if (!pathObject) {
-      return false;
-    }
-    const operation = getResolvedRef(pathObject[method]);
-    if (!operation) {
-      return false;
-    }
-    if (!operation["x-scalar-client-config-request-example"]) {
-      return false;
-    }
-    delete operation["x-scalar-client-config-request-example"][slug];
-    return true;
-  };
-  return {
-    addRequestExample,
-    deleteRequestExample
-  };
-};
-export {
-  requestExampleMutators
-};
-//# sourceMappingURL=request-example.js.map

package/dist/mutators/request-example.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/mutators/request-example.ts"],
-  "sourcesContent": ["import { getResolvedRef } from '@/helpers/get-resolved-ref'\nimport type { OperationIdentifier } from '@/mutators/request'\nimport type { WorkspaceDocument } from '@/schemas'\nimport type { XScalarClientConfigRequestExample } from '@/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example'\n\n/**\n * Provides mutator functions for managing request examples within OpenAPI operations.\n * This module contains utilities for adding and deleting request examples that are\n * stored as custom extensions on OpenAPI operations.\n *\n * @param document - The workspace document to operate on\n * @returns Object containing mutator functions for request example operations\n */\nexport const requestExampleMutators = (document?: WorkspaceDocument) => {\n  /**\n   * Adds a new request example to an OpenAPI operation.\n   * Request examples are stored as custom extensions under the 'x-scalar-client-config-request-example' key.\n   *\n   * @param path - The path of the operation to add the example to\n   * @param method - The HTTP method of the operation\n   * @param slug - A unique identifier for the request example\n   * @param request - The request example configuration to add\n   * @returns true if the example was successfully added, false otherwise\n   *\n   * @example\n   * // Add a request example for a POST operation\n   * addRequestExample({\n   *   path: '/users',\n   *   method: 'post',\n   *   slug: 'create-user',\n   *   request: {\n   *     body: { name: 'John Doe', email: 'john@example.com' },\n   *     headers: { 'Content-Type': 'application/json' }\n   *   }\n   * })\n   */\n  const addRequestExample = ({\n    path,\n    method,\n    slug,\n    request,\n  }: OperationIdentifier & { slug: string; request: XScalarClientConfigRequestExample }) => {\n    if (!document || !document.paths) {\n      return false\n    }\n\n    if (!document.paths[path]) {\n      document.paths[path] = {}\n    }\n\n    if (!document.paths[path][method]) {\n      document.paths[path][method] = {}\n    }\n\n    const operation = getResolvedRef(document.paths[path][method])\n\n    // Create a new request example if it doesn't exist\n    if (!operation['x-scalar-client-config-request-example']) {\n      operation['x-scalar-client-config-request-example'] = {}\n    }\n\n    if (operation['x-scalar-client-config-request-example'][slug]) {\n      console.warn(`Request example with slug \"${slug}\" already exists for ${method.toUpperCase()} ${path}.`)\n      return false\n    }\n\n    operation['x-scalar-client-config-request-example'][slug] = request\n    return true\n  }\n\n  /**\n   * Deletes a request example from an OpenAPI operation by its slug.\n   *\n   * @param path - The path of the operation containing the example\n   * @param method - The HTTP method of the operation\n   * @param slug - The unique identifier of the request example to delete\n   * @returns true if the example was successfully deleted, false otherwise\n   *\n   * @example\n   * // Delete a request example from a POST operation\n   * deleteRequestExample({\n   *   path: '/users',\n   *   method: 'post',\n   *   slug: 'create-user'\n   * })\n   */\n  const deleteRequestExample = ({ path, method, slug }: OperationIdentifier & { slug: string }) => {\n    if (!document) {\n      return false\n    }\n\n    const pathObject = document?.paths?.[path]\n\n    if (!pathObject) {\n      return false\n    }\n\n    const operation = getResolvedRef(pathObject[method])\n\n    if (!operation) {\n      return false\n    }\n\n    if (!operation['x-scalar-client-config-request-example']) {\n      return false\n    }\n\n    // Delete the request example by slug\n    delete operation['x-scalar-client-config-request-example'][slug]\n    return true\n  }\n\n  return {\n    addRequestExample,\n    deleteRequestExample,\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,sBAAsB;AAaxB,MAAM,yBAAyB,CAAC,aAAiC;AAuBtE,QAAM,oBAAoB,CAAC;AAAA,IACzB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,MAA0F;AACxF,QAAI,CAAC,YAAY,CAAC,SAAS,OAAO;AAChC,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,SAAS,MAAM,IAAI,GAAG;AACzB,eAAS,MAAM,IAAI,IAAI,CAAC;AAAA,IAC1B;AAEA,QAAI,CAAC,SAAS,MAAM,IAAI,EAAE,MAAM,GAAG;AACjC,eAAS,MAAM,IAAI,EAAE,MAAM,IAAI,CAAC;AAAA,IAClC;AAEA,UAAM,YAAY,eAAe,SAAS,MAAM,IAAI,EAAE,MAAM,CAAC;AAG7D,QAAI,CAAC,UAAU,wCAAwC,GAAG;AACxD,gBAAU,wCAAwC,IAAI,CAAC;AAAA,IACzD;AAEA,QAAI,UAAU,wCAAwC,EAAE,IAAI,GAAG;AAC7D,cAAQ,KAAK,8BAA8B,IAAI,wBAAwB,OAAO,YAAY,CAAC,IAAI,IAAI,GAAG;AACtG,aAAO;AAAA,IACT;AAEA,cAAU,wCAAwC,EAAE,IAAI,IAAI;AAC5D,WAAO;AAAA,EACT;AAkBA,QAAM,uBAAuB,CAAC,EAAE,MAAM,QAAQ,KAAK,MAA8C;AAC/F,QAAI,CAAC,UAAU;AACb,aAAO;AAAA,IACT;AAEA,UAAM,aAAa,UAAU,QAAQ,IAAI;AAEzC,QAAI,CAAC,YAAY;AACf,aAAO;AAAA,IACT;AAEA,UAAM,YAAY,eAAe,WAAW,MAAM,CAAC;AAEnD,QAAI,CAAC,WAAW;AACd,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,UAAU,wCAAwC,GAAG;AACxD,aAAO;AAAA,IACT;AAGA,WAAO,UAAU,wCAAwC,EAAE,IAAI;AAC/D,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;",
-  "names": []
-}

package/dist/schemas/extensions/security/x-scalar-redirect-uri.d.ts

@@ -1,4 +0,0 @@
-export declare const XScalarRedirectUriSchema: import("@scalar/typebox").TObject<{
-    'x-scalar-redirect-uri': import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
-}>;
-//# sourceMappingURL=x-scalar-redirect-uri.d.ts.map

package/dist/schemas/extensions/security/x-scalar-redirect-uri.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"x-scalar-redirect-uri.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/security/x-scalar-redirect-uri.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;;EAEnC,CAAA"}

package/dist/schemas/extensions/security/x-scalar-redirect-uri.js

@@ -1,8 +0,0 @@
-import { Type } from "@scalar/typebox";
-const XScalarRedirectUriSchema = Type.Object({
-  "x-scalar-redirect-uri": Type.Optional(Type.String())
-});
-export {
-  XScalarRedirectUriSchema
-};
-//# sourceMappingURL=x-scalar-redirect-uri.js.map

package/dist/schemas/extensions/security/x-scalar-redirect-uri.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/schemas/extensions/security/x-scalar-redirect-uri.ts"],
-  "sourcesContent": ["import { Type } from '@scalar/typebox'\n\nexport const XScalarRedirectUriSchema = Type.Object({\n  'x-scalar-redirect-uri': Type.Optional(Type.String()),\n})\n"],
-  "mappings": "AAAA,SAAS,YAAY;AAEd,MAAM,2BAA2B,KAAK,OAAO;AAAA,EAClD,yBAAyB,KAAK,SAAS,KAAK,OAAO,CAAC;AACtD,CAAC;",
-  "names": []
-}

package/dist/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example.d.ts

@@ -1,38 +0,0 @@
-import { type Static, type TLiteral } from '@scalar/typebox';
-export declare const exampleBodyMime: readonly ["application/json", "text/plain", "text/html", "application/javascript", "application/xml", "application/yaml", "application/edn", "application/octet-stream", "application/x-www-form-urlencoded", "multipart/form-data", "binary"];
-declare const xScalarFileValueSchema: import("@scalar/typebox").TUnion<[import("@scalar/typebox").TObject<{
-    url: import("@scalar/typebox").TString;
-    base64: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
-}>, import("@scalar/typebox").TNull]>;
-export type XScalarFileValue = Static<typeof xScalarFileValueSchema>;
-declare const xScalarExampleBodySchema: import("@scalar/typebox").TObject<{
-    encoding: TLiteral<(typeof exampleBodyMime)[number]>;
-    content: import("@scalar/typebox").TUnion<[import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TAny>, import("@scalar/typebox").TString]>;
-    file: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TObject<{
-        url: import("@scalar/typebox").TString;
-        base64: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
-    }>, import("@scalar/typebox").TNull]>>;
-}>;
-export type XScalarExampleBody = Static<typeof xScalarExampleBodySchema>;
-declare const xScalarExampleParameterSchema: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>>;
-export type XScalarExampleParameter = Static<typeof xScalarExampleParameterSchema>;
-export declare const xScalarClientConfigRequestExampleSchema: import("@scalar/typebox").TObject<{
-    name: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
-    body: import("@scalar/typebox").TOptional<import("@scalar/typebox").TObject<{
-        encoding: TLiteral<(typeof exampleBodyMime)[number]>;
-        content: import("@scalar/typebox").TUnion<[import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TAny>, import("@scalar/typebox").TString]>;
-        file: import("@scalar/typebox").TOptional<import("@scalar/typebox").TUnion<[import("@scalar/typebox").TObject<{
-            url: import("@scalar/typebox").TString;
-            base64: import("@scalar/typebox").TOptional<import("@scalar/typebox").TString>;
-        }>, import("@scalar/typebox").TNull]>>;
-    }>>;
-    parameters: import("@scalar/typebox").TOptional<import("@scalar/typebox").TObject<{
-        path: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>>;
-        query: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>>;
-        header: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>>;
-        cookie: import("@scalar/typebox").TOptional<import("@scalar/typebox").TRecord<import("@scalar/typebox").TString, import("@scalar/typebox").TString>>;
-    }>>;
-}>;
-export type XScalarClientConfigRequestExample = Static<typeof xScalarClientConfigRequestExampleSchema>;
-export {};
-//# sourceMappingURL=x-scalar-client-config-request-example.d.ts.map

package/dist/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"x-scalar-client-config-request-example.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAQ,MAAM,iBAAiB,CAAA;AAElE,eAAO,MAAM,eAAe,gPAalB,CAAA;AAEV,QAAA,MAAM,sBAAsB;;;qCAM1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEpE,QAAA,MAAM,wBAAwB;cACsD,QAAQ,CACxF,CAAC,OAAO,eAAe,EAAE,MAAM,CAAC,CACjC;;;;;;EAGD,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAExE,QAAA,MAAM,6BAA6B,8IAA2D,CAAA;AAE9F,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAElF,eAAO,MAAM,uCAAuC;;;kBAbgC,QAAQ,CACxF,CAAC,OAAO,eAAe,EAAE,MAAM,CAAC,CACjC;;;;;;;;;;;;;EAsBF,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG,MAAM,CAAC,OAAO,uCAAuC,CAAC,CAAA"}

package/dist/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example.js

@@ -1,45 +0,0 @@
-import { Type } from "@scalar/typebox";
-const exampleBodyMime = [
-  "application/json",
-  "text/plain",
-  "text/html",
-  "application/javascript",
-  "application/xml",
-  "application/yaml",
-  "application/edn",
-  "application/octet-stream",
-  "application/x-www-form-urlencoded",
-  "multipart/form-data",
-  /** Used for direct files */
-  "binary"
-];
-const xScalarFileValueSchema = Type.Union([
-  Type.Object({
-    url: Type.String(),
-    base64: Type.Optional(Type.String())
-  }),
-  Type.Null()
-]);
-const xScalarExampleBodySchema = Type.Object({
-  encoding: Type.Union(exampleBodyMime.map((it) => Type.Literal(it))),
-  content: Type.Union([Type.Record(Type.String(), Type.Any()), Type.String()]),
-  file: Type.Optional(xScalarFileValueSchema)
-});
-const xScalarExampleParameterSchema = Type.Optional(Type.Record(Type.String(), Type.String()));
-const xScalarClientConfigRequestExampleSchema = Type.Partial(
-  Type.Object({
-    name: Type.String(),
-    body: xScalarExampleBodySchema,
-    parameters: Type.Object({
-      path: xScalarExampleParameterSchema,
-      query: xScalarExampleParameterSchema,
-      header: xScalarExampleParameterSchema,
-      cookie: xScalarExampleParameterSchema
-    })
-  })
-);
-export {
-  exampleBodyMime,
-  xScalarClientConfigRequestExampleSchema
-};
-//# sourceMappingURL=x-scalar-client-config-request-example.js.map

package/dist/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/schemas/v3.1/strict/client-config-extensions/x-scalar-client-config-request-example.ts"],
-  "sourcesContent": ["import { type Static, type TLiteral, Type } from '@scalar/typebox'\n\nexport const exampleBodyMime = [\n  'application/json',\n  'text/plain',\n  'text/html',\n  'application/javascript',\n  'application/xml',\n  'application/yaml',\n  'application/edn',\n  'application/octet-stream',\n  'application/x-www-form-urlencoded',\n  'multipart/form-data',\n  /** Used for direct files */\n  'binary',\n] as const\n\nconst xScalarFileValueSchema = Type.Union([\n  Type.Object({\n    url: Type.String(),\n    base64: Type.Optional(Type.String()),\n  }),\n  Type.Null(),\n])\n\nexport type XScalarFileValue = Static<typeof xScalarFileValueSchema>\n\nconst xScalarExampleBodySchema = Type.Object({\n  encoding: Type.Union(exampleBodyMime.map((it) => Type.Literal(it))) as unknown as TLiteral<\n    (typeof exampleBodyMime)[number]\n  >,\n  content: Type.Union([Type.Record(Type.String(), Type.Any()), Type.String()]),\n  file: Type.Optional(xScalarFileValueSchema),\n})\n\nexport type XScalarExampleBody = Static<typeof xScalarExampleBodySchema>\n\nconst xScalarExampleParameterSchema = Type.Optional(Type.Record(Type.String(), Type.String()))\n\nexport type XScalarExampleParameter = Static<typeof xScalarExampleParameterSchema>\n\nexport const xScalarClientConfigRequestExampleSchema = Type.Partial(\n  Type.Object({\n    name: Type.String(),\n    body: xScalarExampleBodySchema,\n    parameters: Type.Object({\n      path: xScalarExampleParameterSchema,\n      query: xScalarExampleParameterSchema,\n      header: xScalarExampleParameterSchema,\n      cookie: xScalarExampleParameterSchema,\n    }),\n  }),\n)\n\nexport type XScalarClientConfigRequestExample = Static<typeof xScalarClientConfigRequestExampleSchema>\n"],
-  "mappings": "AAAA,SAAqC,YAAY;AAE1C,MAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AACF;AAEA,MAAM,yBAAyB,KAAK,MAAM;AAAA,EACxC,KAAK,OAAO;AAAA,IACV,KAAK,KAAK,OAAO;AAAA,IACjB,QAAQ,KAAK,SAAS,KAAK,OAAO,CAAC;AAAA,EACrC,CAAC;AAAA,EACD,KAAK,KAAK;AACZ,CAAC;AAID,MAAM,2BAA2B,KAAK,OAAO;AAAA,EAC3C,UAAU,KAAK,MAAM,gBAAgB,IAAI,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC,CAAC;AAAA,EAGlE,SAAS,KAAK,MAAM,CAAC,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,IAAI,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;AAAA,EAC3E,MAAM,KAAK,SAAS,sBAAsB;AAC5C,CAAC;AAID,MAAM,gCAAgC,KAAK,SAAS,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,OAAO,CAAC,CAAC;AAItF,MAAM,0CAA0C,KAAK;AAAA,EAC1D,KAAK,OAAO;AAAA,IACV,MAAM,KAAK,OAAO;AAAA,IAClB,MAAM;AAAA,IACN,YAAY,KAAK,OAAO;AAAA,MACtB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,QAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AACH;",
-  "names": []
-}

package/dist/types.d.ts

@@ -1,18 +0,0 @@
-/**
- * Converts a readonly array type to a mutable array type.
- *
- * This utility type removes the readonly modifier from all elements in an array type,
- * allowing the array to be modified. It's useful when you need to work with mutable
- * versions of readonly arrays in TypeScript.
- *
- * @template T - The readonly array type to convert to mutable
- * @example
- * // Convert a readonly array to mutable
- * type ReadonlyNumbers = readonly number[]
- * type MutableNumbers = MutableArray<ReadonlyNumbers>
- * // Result: number[]
- */
-export type MutableArray<T extends readonly any[]> = {
-    -readonly [k in keyof T]: T[k];
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,IAAI;IACnD,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAA"}

package/dist/types.js

@@ -1 +0,0 @@
-//# sourceMappingURL=types.js.map