@scalar/workspace-store 0.68.0 → 0.68.2

package/dist/entities/auth/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/entities/auth/schema.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEpE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE5C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAA;AACxE,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/entities/auth/schema.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEpE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE5C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAA;AACxE,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA"}

package/dist/entities/auth/schema.js

@@ -1,16 +1,20 @@
 import { Type } from '@scalar/typebox';
 import { compose } from '../../schemas/compose.js';
 import { XScalarCredentialsLocationSchema } from '../../schemas/extensions/security/x-scalar-credentials-location.js';
-import { XScalarSecretClientCertificateSchema, XScalarSecretClientIdSchema, XScalarSecretClientSecretSchema, XScalarSecretHTTPSchema, XScalarSecretPrivateKeySchema, XScalarSecretRedirectUriSchema, XScalarSecretRefreshTokenSchema, XScalarSecretServiceNameSchema, XScalarSecretTokenSchema, } from '../../schemas/extensions/security/x-scalar-security-secrets.js';
+import { XScalarAuthUrlSchema, XScalarSecretClientCertificateSchema, XScalarSecretClientIdSchema, XScalarSecretClientSecretSchema, XScalarSecretHTTPSchema, XScalarSecretPrivateKeySchema, XScalarSecretRedirectUriSchema, XScalarSecretRefreshTokenSchema, XScalarSecretServiceNameSchema, XScalarSecretTokenSchema, XScalarTokenUrlSchema, } from '../../schemas/extensions/security/x-scalar-security-secrets.js';
 import { OAuthFlowAuthorizationCodeSchema, OAuthFlowClientCredentialsSchema, OAuthFlowDeviceAuthorizationSchema, OAuthFlowImplicitSchema, OAuthFlowPasswordSchema, } from '../../schemas/v3.2/strict/oauth-flow.js';
 import { SecurityRequirementObjectSchema } from '../../schemas/v3.2/strict/openapi-document.js';
+/** Clear intent is separate from legacy empty values that inherited configured credentials. */
+const ClearedSecretFieldsSchema = Type.Object({
+    'x-scalar-secret-cleared-fields': Type.Optional(Type.Array(Type.String())),
+});
 const SecretsApiKeySchema = compose(Type.Object({
     type: Type.Literal('apiKey'),
-}), XScalarSecretTokenSchema);
+}), XScalarSecretTokenSchema, ClearedSecretFieldsSchema);
 const SecretsHttpSchema = compose(Type.Object({
     type: Type.Literal('http'),
-}), XScalarSecretTokenSchema, XScalarSecretHTTPSchema);
-const SecretsOAuthFlowCommonSchema = compose(XScalarSecretClientIdSchema, XScalarSecretTokenSchema, XScalarSecretRefreshTokenSchema);
+}), XScalarSecretTokenSchema, XScalarSecretHTTPSchema, ClearedSecretFieldsSchema);
+const SecretsOAuthFlowCommonSchema = compose(XScalarAuthUrlSchema, XScalarTokenUrlSchema, ClearedSecretFieldsSchema, XScalarSecretClientIdSchema, XScalarSecretTokenSchema, XScalarSecretRefreshTokenSchema);
 /** An absent stored redirect must fall back to configuration; an empty string means the user cleared it. */
 const StoredRedirectUriSchema = Type.Partial(XScalarSecretRedirectUriSchema);
 const SecretsOAuthFlowsSchema = Type.Object({
@@ -43,19 +47,19 @@ const SecretsSaslSchema = compose(Type.Object({
         Type.Literal('scramSha256'),
         Type.Literal('scramSha512'),
     ]),
-}), XScalarSecretHTTPSchema);
+}), XScalarSecretHTTPSchema, ClearedSecretFieldsSchema);
 /** AsyncAPI X509 broker scheme: a client certificate + private key pair (PEM). */
 const SecretsX509Schema = compose(Type.Object({
     type: Type.Literal('X509'),
-}), XScalarSecretClientCertificateSchema, XScalarSecretPrivateKeySchema);
+}), XScalarSecretClientCertificateSchema, XScalarSecretPrivateKeySchema, ClearedSecretFieldsSchema);
 /** AsyncAPI encryption broker schemes: a single key value, stored in the shared token slot. */
 const SecretsEncryptionSchema = compose(Type.Object({
     type: Type.Union([Type.Literal('symmetricEncryption'), Type.Literal('asymmetricEncryption')]),
-}), XScalarSecretTokenSchema);
+}), XScalarSecretTokenSchema, ClearedSecretFieldsSchema);
 /** AsyncAPI GSSAPI (Kerberos) broker scheme: the service name the client authenticates against. */
 const SecretsGssapiSchema = compose(Type.Object({
     type: Type.Literal('gssapi'),
-}), XScalarSecretServiceNameSchema);
+}), XScalarSecretServiceNameSchema, ClearedSecretFieldsSchema);
 export const SecretsAuthUnionSchema = Type.Union([
     SecretsApiKeySchema,
     SecretsHttpSchema,

package/dist/events/definitions/auth.d.ts

@@ -1,5 +1,6 @@
 import type { PartialDeep } from 'type-fest';
 import type { SecretsAuth } from '../../entities/auth/schema.js';
+import type { AuthSecretField } from '../../helpers/auth-secret-fields.js';
 import type { OAuthFlowsObject, SecurityRequirementObject, SecuritySchemeObject } from '../../schemas/v3.2/strict/openapi-document.js';
 import type { ApiKeyObject, HttpObject, OAuth2Object, OpenIdConnectObject } from '../../schemas/v3.2/strict/security-scheme.js';
 /**
@@ -108,6 +109,12 @@ export type AuthEvents = {
         /** The name of the security scheme to clear */
         name: string;
     };
+    /** Restore one credential's default without clearing the rest of the form. */
+    'auth:reset:security-scheme-secret': {
+        name: string;
+        field: AuthSecretField;
+        flow?: keyof OAuthFlowsObject;
+    };
     /**
      * Update the selected scopes for a given security scheme.
      * Triggers when the user selects/deselects scopes for an OAuth2 (or other scopes-supporting) scheme in the UI.

package/dist/events/definitions/auth.d.ts.map

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

package/dist/helpers/auth-secret-fields.d.ts

@@ -0,0 +1,9 @@
+/** Credential fields that can be cleared or reset without changing a security scheme. */
+export type AuthSecretField = 'x-scalar-secret-client-id' | 'x-scalar-secret-client-secret' | 'x-scalar-secret-password' | 'x-scalar-secret-redirect-uri' | 'x-scalar-secret-token' | 'x-scalar-secret-refresh-token' | 'x-scalar-secret-username' | 'x-scalar-secret-auth-url' | 'x-scalar-secret-token-url';
+/** Legacy empty credentials still inherit defaults; only an explicit clear overrides them. */
+export declare const isSecretFieldCleared: (secrets: object, field: string) => boolean;
+/** Record clear intent from the update, rather than from empty values filled by the store schema. */
+export declare const updateClearedSecretFields: (secrets: Record<string, unknown>, update: Record<string, unknown>) => void;
+/** Release one override so its current document or configured default can take effect. */
+export declare const resetSecretField: (secrets: Record<string, unknown>, field: AuthSecretField) => void;
+//# sourceMappingURL=auth-secret-fields.d.ts.map

package/dist/helpers/auth-secret-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-secret-fields.d.ts","sourceRoot":"","sources":["../../src/helpers/auth-secret-fields.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,MAAM,MAAM,eAAe,GACvB,2BAA2B,GAC3B,+BAA+B,GAC/B,0BAA0B,GAC1B,8BAA8B,GAC9B,uBAAuB,GACvB,+BAA+B,GAC/B,0BAA0B,GAC1B,0BAA0B,GAC1B,2BAA2B,CAAA;AAS/B,8FAA8F;AAC9F,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,EAAE,OAAO,MAAM,KAAG,OAC3B,CAAA;AAE3C,qGAAqG;AACrG,eAAO,MAAM,yBAAyB,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAkB7G,CAAA;AAED,0FAA0F;AAC1F,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,eAAe,KAAG,IAQ3F,CAAA"}

package/dist/helpers/auth-secret-fields.js

@@ -0,0 +1,42 @@
+import { isObjectLike } from '@scalar/helpers/object/is-object';
+const clearedFieldsKey = 'x-scalar-secret-cleared-fields';
+const getClearedFields = (secrets) => {
+    const fields = Reflect.get(secrets, clearedFieldsKey);
+    return Array.isArray(fields) ? fields.filter((field) => typeof field === 'string') : [];
+};
+/** Legacy empty credentials still inherit defaults; only an explicit clear overrides them. */
+export const isSecretFieldCleared = (secrets, field) => getClearedFields(secrets).includes(field);
+/** Record clear intent from the update, rather than from empty values filled by the store schema. */
+export const updateClearedSecretFields = (secrets, update) => {
+    const cleared = new Set(getClearedFields(secrets));
+    for (const [field, value] of Object.entries(update)) {
+        if (field.startsWith('x-scalar-secret-') && field !== clearedFieldsKey && typeof value === 'string') {
+            if (value === '') {
+                cleared.add(field);
+            }
+            else {
+                cleared.delete(field);
+            }
+        }
+        else if (isObjectLike(value) && isObjectLike(secrets[field])) {
+            updateClearedSecretFields(secrets[field], value);
+        }
+    }
+    if (cleared.size) {
+        secrets[clearedFieldsKey] = [...cleared];
+    }
+    else {
+        delete secrets[clearedFieldsKey];
+    }
+};
+/** Release one override so its current document or configured default can take effect. */
+export const resetSecretField = (secrets, field) => {
+    delete secrets[field];
+    const cleared = getClearedFields(secrets).filter((value) => value !== field);
+    if (cleared.length) {
+        secrets[clearedFieldsKey] = cleared;
+    }
+    else {
+        delete secrets[clearedFieldsKey];
+    }
+};

package/dist/helpers/chunk-index.d.ts

@@ -54,6 +54,8 @@ export type ChunkIndex = {
  * to the wrong chunk.
  */
 export declare const fillChunkRef: (template: string, values?: Record<string, string>) => string;
+/** Encodes a component name as a URI-safe JSON Pointer segment for SSR asset references. */
+export declare const encodeSsrComponentName: (value: string) => string;
 /**
  * Builds the reference templates for one document.
  *

package/dist/helpers/chunk-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk-index.d.ts","sourceRoot":"","sources":["../../src/helpers/chunk-index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,yBAAyB,CAAA;AAKrD,0FAA0F;AAC1F,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAA;AAExC,wFAAwF;AACxF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,SAAS,CAAA;IACf;;;;;;OAMG;IACH,IAAI,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAA;IAC3C,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IACpC;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/C,CAAA;AAKD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,EAAE,SAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,KAAG,MAGlF,CAAA;AAwBH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KACtF,iBAkBF,CAAA;AAED,8DAA8D;AAC9D,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,KAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAsC,CAAA;AAEhH;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,oCAAoC,iBAAiB,KAAG,iBAGvF,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,oCAK7B;IACD,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,iBAAiB,CAAA;IACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACnD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/C,KAAG,UAYF,CAAA;AAUF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,OAAO,KAAG,OAqDpD,CAAA"}
+{"version":3,"file":"chunk-index.d.ts","sourceRoot":"","sources":["../../src/helpers/chunk-index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,yBAAyB,CAAA;AAKrD,0FAA0F;AAC1F,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAA;AAExC,wFAAwF;AACxF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,SAAS,CAAA;IACf;;;;;;OAMG;IACH,IAAI,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAA;IAC3C,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IACpC;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/C,CAAA;AAKD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,EAAE,SAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,KAAG,MAGlF,CAAA;AAKH,4FAA4F;AAC5F,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,KAAG,MAAsD,CAAA;AA0B7G;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KACtF,iBAkBF,CAAA;AAED,8DAA8D;AAC9D,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,KAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAsC,CAAA;AAEhH;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,oCAAoC,iBAAiB,KAAG,iBAGvF,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,oCAK7B;IACD,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,iBAAiB,CAAA;IACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACnD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/C,KAAG,UAYF,CAAA;AAUF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,OAAO,KAAG,OAqDpD,CAAA"}

package/dist/helpers/chunk-index.js

@@ -24,6 +24,8 @@ const TEMPLATE_SLOT = /\{\{|\}\}|\{(\w+)\}/g;
 export const fillChunkRef = (template, values = {}) => template.replace(TEMPLATE_SLOT, (match, slot) => slot === undefined ? match.charAt(0) : (values[slot] ?? match));
 /** Escapes text inlined into a template verbatim, so its braces are not read back as slots. */
 const escapeTemplateLiteral = (text) => text.replaceAll('{', '{{').replaceAll('}', '}}');
+/** Encodes a component name as a URI-safe JSON Pointer segment for SSR asset references. */
+export const encodeSsrComponentName = (value) => encodeURIComponent(escapeJsonPointer(value));
 const identity = (value) => value;
 /**
  * How each template slot is spelled, per mode.
@@ -39,7 +41,12 @@ const identity = (value) => value;
  */
 const SLOT_ENCODERS = {
     static: { type: encodeChunkName, name: encodeChunkName, path: encodeChunkName, method: identity },
-    ssr: { type: identity, name: identity, path: escapeJsonPointer, method: identity },
+    ssr: {
+        type: identity,
+        name: encodeSsrComponentName,
+        path: escapeJsonPointer,
+        method: identity,
+    },
 };
 /**
  * Builds the reference templates for one document.

package/dist/helpers/encode-path-parameter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Encodes a path parameter, preserving only path-safe reserved characters and
+ * existing percent-encoded triples when OpenAPI reserved expansion is enabled.
+ * Slashes, query/fragment delimiters, and brackets must remain escaped.
+ */
+export declare const encodePathParameter: (value: string, allowReserved?: boolean) => string;
+/** Style metadata retained until environment substitution and path encoding. */
+export type ReservedPathParameter = {
+    /** Structured input retains array items and object entries for style delimiters. */
+    value: unknown;
+    /** Original preview value lets request hooks override path.variables. */
+    originalValue: string;
+    style: string;
+    explode: boolean;
+};
+/** Serializes OpenAPI reserved path expansion without exposing forbidden delimiters. */
+export declare const serializeReservedPathParameter: (name: string, parameter: Pick<ReservedPathParameter, "value" | "style" | "explode">, replace?: (value: string) => string) => string;
+/** Rejects dot segments that browser URL parsing would silently remove. */
+export declare const assertReservedPathUrl: (url: string) => void;
+//# sourceMappingURL=encode-path-parameter.d.ts.map

package/dist/helpers/encode-path-parameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-path-parameter.d.ts","sourceRoot":"","sources":["../../src/helpers/encode-path-parameter.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,EAAE,uBAAqB,KAAG,MAS1E,CAAA;AAED,gFAAgF;AAChF,MAAM,MAAM,qBAAqB,GAAG;IAClC,oFAAoF;IACpF,KAAK,EAAE,OAAO,CAAA;IACd,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,wFAAwF;AACxF,eAAO,MAAM,8BAA8B,GACzC,MAAM,MAAM,EACZ,WAAW,IAAI,CAAC,qBAAqB,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC,EACrE,UAAS,CAAC,KAAK,EAAE,MAAM,KAAK,MAAyB,KACpD,MAgCF,CAAA;AAED,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,IAKnD,CAAA"}

package/dist/helpers/encode-path-parameter.js

@@ -0,0 +1,51 @@
+import { isObjectLike } from '@scalar/helpers/object/is-object';
+/**
+ * Encodes a path parameter, preserving only path-safe reserved characters and
+ * existing percent-encoded triples when OpenAPI reserved expansion is enabled.
+ * Slashes, query/fragment delimiters, and brackets must remain escaped.
+ */
+export const encodePathParameter = (value, allowReserved = false) => {
+    if (!allowReserved) {
+        return encodeURIComponent(value);
+    }
+    return value.replace(/%[0-9a-f]{2}|[\s\S]/giu, (character) => /^%[0-9a-f]{2}$/i.test(character) || /^[!$&'()*+,;=:@]$/.test(character)
+        ? character
+        : encodeURIComponent(character));
+};
+/** Serializes OpenAPI reserved path expansion without exposing forbidden delimiters. */
+export const serializeReservedPathParameter = (name, parameter, replace = (value) => value) => {
+    const { value, style, explode } = parameter;
+    const encode = (item) => encodePathParameter(replace(String(item)), true);
+    const entries = isObjectLike(value) && !Array.isArray(value) ? Object.entries(value) : undefined;
+    const array = Array.isArray(value) ? value : undefined;
+    if (style === 'matrix') {
+        if (entries && explode) {
+            return entries.map(([key, item]) => `;${encode(key)}=${encode(item)}`).join('');
+        }
+        if (array && explode) {
+            return array.map((item) => `;${encode(name)}=${encode(item)}`).join('');
+        }
+        const data = entries
+            ? entries.flatMap(([key, item]) => [encode(key), encode(item)]).join(',')
+            : array
+                ? array.map(encode).join(',')
+                : encode(value);
+        return `;${encode(name)}=${data}`;
+    }
+    const delimiter = style === 'label' && explode ? '.' : ',';
+    const data = entries
+        ? entries
+            .map(([key, item]) => explode ? `${encode(key)}=${encode(item)}` : `${encode(key)}${delimiter}${encode(item)}`)
+            .join(delimiter)
+        : array
+            ? array.map(encode).join(delimiter)
+            : encode(value);
+    return style === 'label' ? `.${data}` : data;
+};
+/** Rejects dot segments that browser URL parsing would silently remove. */
+export const assertReservedPathUrl = (url) => {
+    const path = url.split(/[?#]/, 1)[0] ?? '';
+    if (path.split('/').some((segment) => /^(?:\.|%2e){1,2}$/i.test(segment))) {
+        throw new URIError('Reserved path parameters cannot form dot segments because browsers normalize them.');
+    }
+};

package/dist/helpers/get-tag-kind.d.ts

@@ -0,0 +1,6 @@
+import type { OpenApiDocument, TagObject } from '../schemas/v3.2/strict/openapi-document.js';
+/** Categories with presentation behavior in Scalar. Custom kinds retain legacy navigation. */
+export type TagKind = 'nav' | 'badge' | 'audience';
+/** Only OpenAPI 3.2 gives tag kinds meaning; earlier documents keep their existing groups. */
+export declare const getTagKind: (document: Pick<OpenApiDocument, "openapi">, tag?: TagObject) => TagKind;
+//# sourceMappingURL=get-tag-kind.d.ts.map

package/dist/helpers/get-tag-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-tag-kind.d.ts","sourceRoot":"","sources":["../../src/helpers/get-tag-kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAA;AAExF,8FAA8F;AAC9F,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,CAAA;AAElD,8FAA8F;AAC9F,eAAO,MAAM,UAAU,GAAI,UAAU,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,EAAE,MAAM,SAAS,KAAG,OAKxF,CAAA"}

package/dist/helpers/get-tag-kind.js

@@ -0,0 +1,7 @@
+/** Only OpenAPI 3.2 gives tag kinds meaning; earlier documents keep their existing groups. */
+export const getTagKind = (document, tag) => {
+    if (document.openapi.startsWith('3.2.') && (tag?.kind === 'badge' || tag?.kind === 'audience')) {
+        return tag.kind;
+    }
+    return 'nav';
+};

package/dist/helpers/resolve-form-schema.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaObject } from '../schemas/v3.2/strict/openapi-document.js';
+import type { MaybeRefSchemaObject } from '../schemas/v3.2/strict/schema.js';
+/**
+ * Expose the selected request-body shape to form editors and serializers without changing the
+ * API description. Use the example generator's branch selection so field types match its values.
+ * Unselected alternatives remain on the view for validation, but do not contribute form fields.
+ */
+export declare const resolveFormSchema: (schema: MaybeRefSchemaObject | undefined, compositionSelection?: Record<string, number>) => SchemaObject | undefined;
+//# sourceMappingURL=resolve-form-schema.d.ts.map

package/dist/helpers/resolve-form-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-form-schema.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-form-schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAMxE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,oBAAoB,GAAG,SAAS,EACxC,uBAAuB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC5C,YAAY,GAAG,SAyJjB,CAAA"}

package/dist/helpers/resolve-form-schema.js

@@ -0,0 +1,143 @@
+import { objectEntries } from '@scalar/helpers/object/object-entries';
+import { selectExampleComposition } from '../request-example/builder/helpers/get-example-from-schema.js';
+import { resolve } from '../resolve.js';
+import { isNumberSchema, isObjectSchema } from '../schemas/v3.2/strict/type-guards.js';
+import { getSchemaAnnotations, resolveSchemaWithAnnotations } from './resolve-schema-with-annotations.js';
+import { unpackProxyShallow } from './unpack-proxy.js';
+/**
+ * Expose the selected request-body shape to form editors and serializers without changing the
+ * API description. Use the example generator's branch selection so field types match its values.
+ * Unselected alternatives remain on the view for validation, but do not contribute form fields.
+ */
+export const resolveFormSchema = (schema, compositionSelection) => {
+    const ancestors = new Set();
+    const visit = (input, path, selection) => {
+        const source = resolve.schema(input);
+        const resolved = resolveSchemaWithAnnotations(input);
+        if (!source || !resolved || !input) {
+            return resolved;
+        }
+        const identity = unpackProxyShallow(input);
+        // Recursive properties remain opaque leaves instead of expanding an infinite form.
+        if (ancestors.has(identity)) {
+            return isObjectSchema(resolved) ? { ...resolved, properties: undefined } : resolved;
+        }
+        ancestors.add(identity);
+        try {
+            if (source.allOf?.length) {
+                let choiceIndex = 0;
+                const members = source.allOf.map((member) => {
+                    const memberSchema = resolve.schema(member);
+                    const isChoice = Boolean(memberSchema?.oneOf || memberSchema?.anyOf);
+                    return visit(member, isChoice ? [...path, String(choiceIndex++)] : path, selection) ?? member;
+                });
+                if (!resolved.allOf) {
+                    return resolveSchemaWithAnnotations({ ...source, allOf: members });
+                }
+                const { allOf: _allOf, ...siblings } = source;
+                const parts = [visit(siblings, path, selection), ...members].filter((member) => member !== undefined);
+                const typed = parts.filter((member) => 'type' in member && member.type !== undefined);
+                const first = typed[0];
+                if (!first || !('type' in first) || Array.isArray(first.type)) {
+                    return resolved;
+                }
+                const type = typed.some((member) => 'type' in member && member.type === 'integer') &&
+                    (first.type === 'integer' || first.type === 'number')
+                    ? 'integer'
+                    : first.type;
+                // Incompatible intersections have no single input type. Keep them as opaque leaves.
+                if (typed.some((member) => 'type' in member && member.type !== type && !(type === 'integer' && member.type === 'number'))) {
+                    return resolved;
+                }
+                const annotations = Object.assign({}, ...parts.map(getSchemaAnnotations));
+                const result = { ...first, ...annotations, ...siblings, type, allOf: source.allOf };
+                Reflect.deleteProperty(result, '__scalar_');
+                if (isObjectSchema(result)) {
+                    const properties = {};
+                    const required = new Set();
+                    for (const part of parts) {
+                        if ('required' in part) {
+                            for (const name of part.required ?? []) {
+                                required.add(name);
+                            }
+                        }
+                        if ('properties' in part) {
+                            for (const [name, child] of objectEntries(part.properties ?? {})) {
+                                const previous = properties[name];
+                                properties[name] = previous
+                                    ? (visit({ __scalar_: '', allOf: [previous, child] }, [...path, name], selection) ?? child)
+                                    : child;
+                            }
+                        }
+                    }
+                    result.properties = properties;
+                    result.required = [...required];
+                }
+                if (isNumberSchema(result)) {
+                    const minima = parts.flatMap((part) => 'minimum' in part && part.minimum !== undefined ? [part.minimum] : []);
+                    const maxima = parts.flatMap((part) => 'maximum' in part && part.maximum !== undefined ? [part.maximum] : []);
+                    if (minima.length) {
+                        result.minimum = Math.max(...minima);
+                    }
+                    if (maxima.length) {
+                        result.maximum = Math.min(...maxima);
+                    }
+                }
+                return result;
+            }
+            const properties = isObjectSchema(resolved) && resolved.properties
+                ? Object.fromEntries(objectEntries(resolved.properties).map(([key, child]) => [
+                    key,
+                    visit(child, [...path, key], selection) ?? child,
+                ]))
+                : undefined;
+            const base = properties ? { ...resolved, properties } : resolved;
+            const keyword = resolved.oneOf ? 'oneOf' : 'anyOf';
+            const candidate = selectExampleComposition(resolved, path, { compositionSelection: selection });
+            if (!candidate) {
+                return base;
+            }
+            const selectionKey = [...path, keyword].join('.');
+            const { [selectionKey]: _selection, ...remainingSelection } = selection ?? {};
+            const selected = visit(candidate, path, remainingSelection);
+            if (!selected) {
+                return base;
+            }
+            const result = { ...base, ...selected, [keyword]: resolved[keyword] };
+            if ('type' in result) {
+                Reflect.deleteProperty(result, '__scalar_');
+            }
+            if (isNumberSchema(result)) {
+                // Parent and branch bounds both apply; selecting a variant must not weaken validation.
+                if ('minimum' in base &&
+                    'minimum' in selected &&
+                    base.minimum !== undefined &&
+                    selected.minimum !== undefined) {
+                    result.minimum = Math.max(base.minimum, selected.minimum);
+                }
+                if ('maximum' in base &&
+                    'maximum' in selected &&
+                    base.maximum !== undefined &&
+                    selected.maximum !== undefined) {
+                    result.maximum = Math.min(base.maximum, selected.maximum);
+                }
+            }
+            if (resolved.description !== undefined) {
+                result.description = resolved.description;
+            }
+            if (isObjectSchema(result)) {
+                const baseProperties = 'properties' in base ? base.properties : undefined;
+                const selectedProperties = 'properties' in selected ? selected.properties : undefined;
+                const baseRequired = 'required' in base ? base.required : undefined;
+                const selectedRequired = 'required' in selected ? selected.required : undefined;
+                result.properties = { ...baseProperties, ...selectedProperties };
+                result.required = [...new Set([...(baseRequired ?? []), ...(selectedRequired ?? [])])];
+            }
+            return result;
+        }
+        finally {
+            ancestors.delete(identity);
+        }
+    };
+    return visit(schema, ['requestBody'], compositionSelection);
+};

package/dist/helpers/resolve-schema-with-annotations.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaObject } from '../schemas/v3.2/strict/openapi-document.js';
+import type { MaybeRefSchemaObject } from '../schemas/v3.2/strict/schema.js';
+/** Extract annotation keywords without copying validation constraints into a form projection. */
+export declare const getSchemaAnnotations: (schema: SchemaObject) => Record<string, unknown>;
+/**
+ * Expose the value schema inside an annotation-only allOf wrapper for form editors and serializers.
+ * Multiple value schemas retain their composition, since combining their constraints requires more
+ * than spreading their keywords. The returned view does not mutate the API description.
+ */
+export declare const resolveSchemaWithAnnotations: (schema: MaybeRefSchemaObject | undefined) => SchemaObject | undefined;
+//# sourceMappingURL=resolve-schema-with-annotations.d.ts.map

package/dist/helpers/resolve-schema-with-annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-schema-with-annotations.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-schema-with-annotations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAmBxE,iGAAiG;AACjG,eAAO,MAAM,oBAAoB,GAAI,QAAQ,YAAY,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CACK,CAAA;AAEvF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,GAAI,QAAQ,oBAAoB,GAAG,SAAS,KAAG,YAAY,GAAG,SAuCtG,CAAA"}

package/dist/helpers/resolve-schema-with-annotations.js

@@ -0,0 +1,57 @@
+import { resolve } from '../resolve.js';
+import { unpackProxyShallow } from './unpack-proxy.js';
+const annotationKeys = new Set([
+    'title',
+    'description',
+    'default',
+    'examples',
+    'example',
+    'deprecated',
+    'readOnly',
+    'writeOnly',
+    '$comment',
+    'externalDocs',
+    // TypeBox marks schemas without an explicit type; this does not constrain their value.
+    '__scalar_',
+]);
+/** Extract annotation keywords without copying validation constraints into a form projection. */
+export const getSchemaAnnotations = (schema) => Object.fromEntries(Object.entries(schema).filter(([key]) => annotationKeys.has(key)));
+/**
+ * Expose the value schema inside an annotation-only allOf wrapper for form editors and serializers.
+ * Multiple value schemas retain their composition, since combining their constraints requires more
+ * than spreading their keywords. The returned view does not mutate the API description.
+ */
+export const resolveSchemaWithAnnotations = (schema) => {
+    const seen = new Set();
+    const visit = (input) => {
+        const resolved = resolve.schema(input);
+        if (!resolved?.allOf?.length || !input) {
+            return resolved;
+        }
+        if (Object.keys(resolved).some((key) => key !== 'allOf' && key !== '$ref' && !annotationKeys.has(key))) {
+            return resolved;
+        }
+        const identity = unpackProxyShallow(input);
+        if (seen.has(identity)) {
+            return resolved;
+        }
+        seen.add(identity);
+        const members = resolved.allOf.map((member) => resolve.schema(member));
+        if (members.some((member) => !member)) {
+            return resolved;
+        }
+        const valueMembers = members.filter((member) => member && Object.keys(member).some((key) => !annotationKeys.has(key)));
+        const valueMember = valueMembers[0];
+        if (valueMembers.length !== 1 || !valueMember) {
+            return resolved;
+        }
+        const valueIndex = members.indexOf(valueMember);
+        const valueSchema = visit(resolved.allOf[valueIndex]);
+        const annotations = Object.assign({}, ...members.filter((member) => member !== valueMember && member !== undefined).map(getSchemaAnnotations));
+        const { allOf: _allOf, ...siblings } = resolved;
+        const result = { ...valueSchema, ...annotations, ...siblings };
+        Reflect.deleteProperty(result, '__scalar_');
+        return result;
+    };
+    return visit(schema);
+};

package/dist/helpers/resolve-security-requirements.d.ts

@@ -0,0 +1,15 @@
+import { type LoaderPlugin } from '@scalar/json-magic/bundle';
+type SecurityUriOptions = {
+    origin?: string;
+    loaders: LoaderPlugin[];
+};
+/**
+ * Makes URI requirements available to the existing name-based auth consumers.
+ * Aliases live only in the working document; export removes them and restores authored keys.
+ * Relative keys in referenced documents become absolute to keep distinct document bases apart.
+ */
+export declare const resolveSecurityRequirements: (document: Record<string, unknown>, { origin, loaders }: SecurityUriOptions) => Promise<void>;
+/** Remove runtime URI aliases while keeping edited scopes and authored requirement spellings. */
+export declare const restoreSecurityRequirements: (document: Record<string, unknown>) => void;
+export {};
+//# sourceMappingURL=resolve-security-requirements.d.ts.map

package/dist/helpers/resolve-security-requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-security-requirements.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-security-requirements.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAAgC,MAAM,2BAA2B,CAAA;AAa3F,KAAK,kBAAkB,GAAG;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,YAAY,EAAE,CAAA;CACxB,CAAA;AAUD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GACtC,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,qBAA2B,kBAAkB,KAC5C,OAAO,CAAC,IAAI,CA4Id,CAAA;AAED,iGAAiG;AACjG,eAAO,MAAM,2BAA2B,GAAI,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAsD/E,CAAA"}