@opengeni/contracts 3.1.0-canary.1 → 3.1.2

package/dist/knowledge-preparation.d.ts

@@ -0,0 +1,239 @@
+import { z } from "zod";
+/** Read-only discovery before a model decides whether and where to save. */
+export declare const KnowledgeSavePreparationRequest: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    collectionCursors: z.ZodOptional<z.ZodObject<{
+        published: z.ZodNullable<z.ZodString>;
+        needs_review: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KnowledgeSavePreparationRequest = z.input<typeof KnowledgeSavePreparationRequest>;
+export declare const KnowledgeCollectionDescriptor: z.ZodObject<{
+    id: z.ZodUUID;
+    revisionId: z.ZodUUID;
+    version: z.ZodNumber;
+    scope: z.ZodEnum<{
+        organization: "organization";
+        personal: "personal";
+        workspace: "workspace";
+    }>;
+    view: z.ZodEnum<{
+        needs_review: "needs_review";
+        published: "published";
+    }>;
+    title: z.ZodString;
+    description: z.ZodString;
+    descriptionTruncated: z.ZodBoolean;
+    parentIds: z.ZodArray<z.ZodUUID>;
+}, z.core.$strict>;
+export declare const KnowledgeSavePreparationResponse: z.ZodObject<{
+    collections: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            revisionId: z.ZodUUID;
+            version: z.ZodNumber;
+            scope: z.ZodEnum<{
+                organization: "organization";
+                personal: "personal";
+                workspace: "workspace";
+            }>;
+            view: z.ZodEnum<{
+                needs_review: "needs_review";
+                published: "published";
+            }>;
+            title: z.ZodString;
+            description: z.ZodString;
+            descriptionTruncated: z.ZodBoolean;
+            parentIds: z.ZodArray<z.ZodUUID>;
+        }, z.core.$strict>>;
+        complete: z.ZodBoolean;
+        nextCursors: z.ZodObject<{
+            published: z.ZodNullable<z.ZodString>;
+            needs_review: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    matches: z.ZodObject<{
+        published: z.ZodObject<{
+            entries: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                scope: z.ZodEnum<{
+                    organization: "organization";
+                    personal: "personal";
+                    workspace: "workspace";
+                }>;
+                version: z.ZodNumber;
+                publishedRevisionId: z.ZodNullable<z.ZodUUID>;
+                latestRevisionId: z.ZodUUID;
+                archived: z.ZodBoolean;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                indexStatus: z.ZodOptional<z.ZodEnum<{
+                    awaiting_funding: "awaiting_funding";
+                    indexed: "indexed";
+                    indexing: "indexing";
+                    provider_failed: "provider_failed";
+                    queued: "queued";
+                    saved: "saved";
+                    source_unavailable: "source_unavailable";
+                }>>;
+                score: z.ZodOptional<z.ZodNumber>;
+                excerpts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    field: z.ZodEnum<{
+                        content: "content";
+                        title: "title";
+                    }>;
+                    start: z.ZodNumber;
+                    end: z.ZodNumber;
+                    text: z.ZodString;
+                }, z.core.$strip>>>;
+                revision: z.ZodObject<{
+                    id: z.ZodUUID;
+                    entryId: z.ZodUUID;
+                    number: z.ZodNumber;
+                    change: z.ZodEnum<{
+                        archive: "archive";
+                        upsert: "upsert";
+                    }>;
+                    previousRevisionId: z.ZodNullable<z.ZodUUID>;
+                    restoredFromRevisionId: z.ZodNullable<z.ZodUUID>;
+                    createdAt: z.ZodString;
+                    createdBySessionId: z.ZodNullable<z.ZodUUID>;
+                    reviewBatchId: z.ZodNullable<z.ZodUUID>;
+                    outcome: z.ZodEnum<{
+                        pending: "pending";
+                        published: "published";
+                        rejected: "rejected";
+                        superseded: "superseded";
+                    }>;
+                    title: z.ZodString;
+                    kind: z.ZodEnum<{
+                        decision: "decision";
+                        fact: "fact";
+                        group: "group";
+                        incident: "incident";
+                        note: "note";
+                        requirement: "requirement";
+                        source: "source";
+                    }>;
+                    preview: z.ZodString;
+                    groupIds: z.ZodArray<z.ZodUUID>;
+                    sourceKind: z.ZodNullable<z.ZodEnum<{
+                        connector: "connector";
+                        conversation: "conversation";
+                        file: "file";
+                        manual: "manual";
+                        repository: "repository";
+                        slack: "slack";
+                        task_note: "task_note";
+                        web: "web";
+                    }>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            nextCursor: z.ZodNullable<z.ZodString>;
+            searchMode: z.ZodOptional<z.ZodEnum<{
+                hybrid: "hybrid";
+                keyword: "keyword";
+                vector: "vector";
+            }>>;
+            fallbackReason: z.ZodOptional<z.ZodEnum<{
+                awaiting_funding: "awaiting_funding";
+                credits_disabled: "credits_disabled";
+                provider_unavailable: "provider_unavailable";
+                query_limit: "query_limit";
+                quota: "quota";
+            }>>;
+        }, z.core.$strip>;
+        needs_review: z.ZodObject<{
+            entries: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                scope: z.ZodEnum<{
+                    organization: "organization";
+                    personal: "personal";
+                    workspace: "workspace";
+                }>;
+                version: z.ZodNumber;
+                publishedRevisionId: z.ZodNullable<z.ZodUUID>;
+                latestRevisionId: z.ZodUUID;
+                archived: z.ZodBoolean;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                indexStatus: z.ZodOptional<z.ZodEnum<{
+                    awaiting_funding: "awaiting_funding";
+                    indexed: "indexed";
+                    indexing: "indexing";
+                    provider_failed: "provider_failed";
+                    queued: "queued";
+                    saved: "saved";
+                    source_unavailable: "source_unavailable";
+                }>>;
+                score: z.ZodOptional<z.ZodNumber>;
+                excerpts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    field: z.ZodEnum<{
+                        content: "content";
+                        title: "title";
+                    }>;
+                    start: z.ZodNumber;
+                    end: z.ZodNumber;
+                    text: z.ZodString;
+                }, z.core.$strip>>>;
+                revision: z.ZodObject<{
+                    id: z.ZodUUID;
+                    entryId: z.ZodUUID;
+                    number: z.ZodNumber;
+                    change: z.ZodEnum<{
+                        archive: "archive";
+                        upsert: "upsert";
+                    }>;
+                    previousRevisionId: z.ZodNullable<z.ZodUUID>;
+                    restoredFromRevisionId: z.ZodNullable<z.ZodUUID>;
+                    createdAt: z.ZodString;
+                    createdBySessionId: z.ZodNullable<z.ZodUUID>;
+                    reviewBatchId: z.ZodNullable<z.ZodUUID>;
+                    outcome: z.ZodEnum<{
+                        pending: "pending";
+                        published: "published";
+                        rejected: "rejected";
+                        superseded: "superseded";
+                    }>;
+                    title: z.ZodString;
+                    kind: z.ZodEnum<{
+                        decision: "decision";
+                        fact: "fact";
+                        group: "group";
+                        incident: "incident";
+                        note: "note";
+                        requirement: "requirement";
+                        source: "source";
+                    }>;
+                    preview: z.ZodString;
+                    groupIds: z.ZodArray<z.ZodUUID>;
+                    sourceKind: z.ZodNullable<z.ZodEnum<{
+                        connector: "connector";
+                        conversation: "conversation";
+                        file: "file";
+                        manual: "manual";
+                        repository: "repository";
+                        slack: "slack";
+                        task_note: "task_note";
+                        web: "web";
+                    }>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            nextCursor: z.ZodNullable<z.ZodString>;
+            searchMode: z.ZodOptional<z.ZodEnum<{
+                hybrid: "hybrid";
+                keyword: "keyword";
+                vector: "vector";
+            }>>;
+            fallbackReason: z.ZodOptional<z.ZodEnum<{
+                awaiting_funding: "awaiting_funding";
+                credits_disabled: "credits_disabled";
+                provider_unavailable: "provider_unavailable";
+                query_limit: "query_limit";
+                quota: "quota";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type KnowledgeSavePreparationResponse = z.infer<typeof KnowledgeSavePreparationResponse>;

package/dist/managed-auth-session-sets.d.ts

@@ -112,6 +112,13 @@ export declare const StartManagedAuthSocialTransactionRequest: z.ZodObject<{
         github: "github";
         google: "google";
     }>;
+    attribution: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        utmSource: z.ZodOptional<z.ZodString>;
+        utmMedium: z.ZodOptional<z.ZodString>;
+        utmCampaign: z.ZodOptional<z.ZodString>;
+        utmContent: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
 }, z.core.$strip>;
 export type StartManagedAuthSocialTransactionRequest = z.infer<typeof StartManagedAuthSocialTransactionRequest>;
 export declare const StartManagedAuthSocialTransactionResponse: z.ZodObject<{

package/dist/managed-auth-session-sets.js

@@ -1,3 +1,7 @@
+import {
+  defineSchema
+} from "./chunk-56SNIMDO.js";
+
 // src/managed-auth-session-sets.ts
 import { z } from "zod";
 var MANAGED_AUTH_SESSION_SET_MAX_SLOTS = 8;
@@ -5,144 +9,206 @@ var MANAGED_AUTH_TRANSACTION_TTL_SECONDS = 600;
 var MANAGED_AUTH_RETURN_INTENT_MAX_BYTES = 2048;
 var MANAGED_AUTH_SESSION_SET_API_CONTRACT_HEADER = "x-opengeni-api-contract";
 var MANAGED_AUTH_SESSION_SET_API_CONTRACT_REVISION = "2026-08-personal-only-organization-setup-v1";
-var ManagedAuthSessionSetMode = z.enum(["legacy", "dual", "broker"]);
-var ManagedAuthLoginSlotState = z.enum(["active", "reauth_required"]);
-var ManagedAuthVerifiedClaim = z.object({
-  kind: z.literal("email"),
-  value: z.string().email().max(320)
-});
-var ManagedAuthLoginSlot = z.object({
-  id: z.string().uuid(),
-  displayName: z.string().min(1).max(256),
-  verifiedClaim: ManagedAuthVerifiedClaim,
-  state: ManagedAuthLoginSlotState
-});
-var ManagedAuthSessionSetState = z.enum(["ready", "actor_change_required"]);
-var ManagedAuthSessionSetProjection = z.object({
-  mode: ManagedAuthSessionSetMode,
-  generation: z.string().regex(/^[1-9][0-9]*$/),
-  actorEpoch: z.string().regex(/^[1-9][0-9]*$/),
-  csrfToken: z.string().min(32).max(512),
-  selectedSlotId: z.string().uuid().nullable(),
-  state: ManagedAuthSessionSetState,
-  slots: z.array(ManagedAuthLoginSlot).max(MANAGED_AUTH_SESSION_SET_MAX_SLOTS)
-});
-var ManagedAuthOperationIdentity = z.object({
-  operationId: z.string().uuid(),
-  expectedGeneration: z.string().regex(/^[1-9][0-9]*$/)
-});
+var ManagedAuthSessionSetMode = /* @__PURE__ */ defineSchema(
+  () => z.enum(["legacy", "dual", "broker"])
+);
+var ManagedAuthLoginSlotState = /* @__PURE__ */ defineSchema(
+  () => z.enum(["active", "reauth_required"])
+);
+var ManagedAuthVerifiedClaim = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    kind: z.literal("email"),
+    value: z.string().email().max(320)
+  })
+);
+var ManagedAuthLoginSlot = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    id: z.string().uuid(),
+    displayName: z.string().min(1).max(256),
+    verifiedClaim: ManagedAuthVerifiedClaim,
+    state: ManagedAuthLoginSlotState
+  })
+);
+var ManagedAuthSessionSetState = /* @__PURE__ */ defineSchema(
+  () => z.enum(["ready", "actor_change_required"])
+);
+var ManagedAuthSessionSetProjection = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    mode: ManagedAuthSessionSetMode,
+    generation: z.string().regex(/^[1-9][0-9]*$/),
+    actorEpoch: z.string().regex(/^[1-9][0-9]*$/),
+    csrfToken: z.string().min(32).max(512),
+    selectedSlotId: z.string().uuid().nullable(),
+    state: ManagedAuthSessionSetState,
+    slots: z.array(ManagedAuthLoginSlot).max(MANAGED_AUTH_SESSION_SET_MAX_SLOTS)
+  })
+);
+var ManagedAuthOperationIdentity = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    operationId: z.string().uuid(),
+    expectedGeneration: z.string().regex(/^[1-9][0-9]*$/)
+  })
+);
 var BootstrapManagedAuthSessionSetRequest = ManagedAuthOperationIdentity;
-var ManagedAuthReturnIntent = z.string().min(1).superRefine((value, context) => {
-  if (new TextEncoder().encode(value).byteLength > MANAGED_AUTH_RETURN_INTENT_MAX_BYTES) {
-    context.addIssue({ code: "custom", message: "return intent exceeds its UTF-8 byte limit" });
-  }
-  if (!value.startsWith("/") || value.startsWith("//") || value.includes("?") || value.includes("#") || /[\u0000-\u001f\u007f\\]/.test(value)) {
-    context.addIssue({
-      code: "custom",
-      message: "return intent must be a safe same-origin path"
-    });
-    return;
-  }
-  try {
-    const parsed = new URL(value, "https://opengeni.invalid");
-    const uuid = "[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}";
-    const supportedPath = new RegExp(
-      `^/(?:sessions/${uuid}|workspaces/${uuid}(?:/sessions(?:/${uuid})?)?)$`,
-      "i"
-    );
-    if (parsed.origin !== "https://opengeni.invalid" || parsed.username || parsed.password || parsed.search || parsed.hash || !supportedPath.test(value) || parsed.pathname !== value) {
+var ManagedAuthReturnIntent = /* @__PURE__ */ defineSchema(
+  () => z.string().min(1).superRefine((value, context) => {
+    if (new TextEncoder().encode(value).byteLength > MANAGED_AUTH_RETURN_INTENT_MAX_BYTES) {
+      context.addIssue({ code: "custom", message: "return intent exceeds its UTF-8 byte limit" });
+    }
+    if (!value.startsWith("/") || value.startsWith("//") || value.includes("?") || value.includes("#") || /[\u0000-\u001f\u007f\\]/.test(value)) {
+      context.addIssue({
+        code: "custom",
+        message: "return intent must be a safe same-origin path"
+      });
+      return;
+    }
+    try {
+      const parsed = new URL(value, "https://opengeni.invalid");
+      const uuid = "[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}";
+      const supportedPath = new RegExp(
+        `^/(?:sessions/${uuid}|workspaces/${uuid}(?:/sessions(?:/${uuid})?)?)$`,
+        "i"
+      );
+      if (parsed.origin !== "https://opengeni.invalid" || parsed.username || parsed.password || parsed.search || parsed.hash || !supportedPath.test(value) || parsed.pathname !== value) {
+        context.addIssue({
+          code: "custom",
+          message: "return intent contains unsafe authority data"
+        });
+      }
+    } catch {
+      context.addIssue({
+        code: "custom",
+        message: "return intent is not a valid same-origin path"
+      });
+    }
+  })
+);
+var BeginManagedAuthLoginTransactionRequest = /* @__PURE__ */ defineSchema(
+  () => ManagedAuthOperationIdentity.extend({
+    kind: z.enum(["add", "reauth"]),
+    slotId: z.string().uuid().optional(),
+    returnIntent: ManagedAuthReturnIntent.optional()
+  }).superRefine((value, context) => {
+    if (value.kind === "reauth" !== Boolean(value.slotId)) {
       context.addIssue({
         code: "custom",
-        message: "return intent contains unsafe authority data"
+        path: ["slotId"],
+        message: "reauth requires exactly one slot id and add forbids one"
       });
     }
-  } catch {
-    context.addIssue({
-      code: "custom",
-      message: "return intent is not a valid same-origin path"
-    });
-  }
-});
-var BeginManagedAuthLoginTransactionRequest = ManagedAuthOperationIdentity.extend({
-  kind: z.enum(["add", "reauth"]),
-  slotId: z.string().uuid().optional(),
-  returnIntent: ManagedAuthReturnIntent.optional()
-}).superRefine((value, context) => {
-  if (value.kind === "reauth" !== Boolean(value.slotId)) {
-    context.addIssue({
-      code: "custom",
-      path: ["slotId"],
-      message: "reauth requires exactly one slot id and add forbids one"
-    });
-  }
-});
-var ManagedAuthLoginTransaction = z.object({
-  id: z.string().uuid(),
-  kind: z.enum(["add", "reauth"]),
-  expiresAt: z.string().datetime(),
-  returnIntentId: z.string().uuid().nullable()
-});
-var ManagedAuthSocialProvider = z.enum(["google", "github"]);
-var StartManagedAuthSocialTransactionRequest = ManagedAuthOperationIdentity.extend({
-  transactionId: z.string().uuid(),
-  provider: ManagedAuthSocialProvider
-});
-var StartManagedAuthSocialTransactionResponse = z.object({
-  url: z.string().url().max(4096)
-});
-var CompleteManagedAuthEmailPasswordTransactionRequest = ManagedAuthOperationIdentity.extend({
-  transactionId: z.string().uuid(),
-  email: z.string().email().max(320),
-  password: z.string().min(1).max(1024)
-});
-var CompleteManagedAuthLoginTransactionResponse = z.object({
-  projection: ManagedAuthSessionSetProjection,
-  returnIntent: ManagedAuthReturnIntent.nullable()
-});
-var CancelManagedAuthLoginTransactionRequest = ManagedAuthOperationIdentity.extend({
-  transactionId: z.string().uuid()
-});
-var SelectManagedAuthLoginSlotRequest = ManagedAuthOperationIdentity.extend({
-  slotId: z.string().uuid()
-});
-var LogoutManagedAuthLoginSlotRequest = ManagedAuthOperationIdentity.extend({
-  slotId: z.string().uuid(),
-  replacementSlotId: z.string().uuid().nullable()
-});
+  })
+);
+var ManagedAuthLoginTransaction = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    id: z.string().uuid(),
+    kind: z.enum(["add", "reauth"]),
+    expiresAt: z.string().datetime(),
+    returnIntentId: z.string().uuid().nullable()
+  })
+);
+var ManagedAuthSocialProvider = /* @__PURE__ */ defineSchema(
+  () => z.enum(["google", "github"])
+);
+var SocialStartAttributionValue = /* @__PURE__ */ defineSchema(
+  () => z.string().trim().min(1).max(100).regex(/^[A-Za-z0-9._~+-]+$/)
+);
+var SocialStartAttribution = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    utmSource: SocialStartAttributionValue.optional(),
+    utmMedium: SocialStartAttributionValue.optional(),
+    utmCampaign: SocialStartAttributionValue.optional(),
+    utmContent: SocialStartAttributionValue.optional(),
+    ref: SocialStartAttributionValue.optional()
+  }).strict()
+);
+var StartManagedAuthSocialTransactionRequest = /* @__PURE__ */ defineSchema(
+  () => ManagedAuthOperationIdentity.extend({
+    transactionId: z.string().uuid(),
+    provider: ManagedAuthSocialProvider,
+    /**
+     * Optional untrusted first-touch campaign tokens, used only by the
+     * content-free sign-up acquisition counter when this start creates a new
+     * account. Invalid attribution is dropped rather than failing the sign-in.
+     */
+    attribution: SocialStartAttribution.optional().catch(void 0)
+  })
+);
+var StartManagedAuthSocialTransactionResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    url: z.string().url().max(4096)
+  })
+);
+var CompleteManagedAuthEmailPasswordTransactionRequest = /* @__PURE__ */ defineSchema(
+  () => ManagedAuthOperationIdentity.extend({
+    transactionId: z.string().uuid(),
+    email: z.string().email().max(320),
+    password: z.string().min(1).max(1024)
+  })
+);
+var CompleteManagedAuthLoginTransactionResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    projection: ManagedAuthSessionSetProjection,
+    returnIntent: ManagedAuthReturnIntent.nullable()
+  })
+);
+var CancelManagedAuthLoginTransactionRequest = /* @__PURE__ */ defineSchema(
+  () => ManagedAuthOperationIdentity.extend({
+    transactionId: z.string().uuid()
+  })
+);
+var SelectManagedAuthLoginSlotRequest = /* @__PURE__ */ defineSchema(
+  () => ManagedAuthOperationIdentity.extend({
+    slotId: z.string().uuid()
+  })
+);
+var LogoutManagedAuthLoginSlotRequest = /* @__PURE__ */ defineSchema(
+  () => ManagedAuthOperationIdentity.extend({
+    slotId: z.string().uuid(),
+    replacementSlotId: z.string().uuid().nullable()
+  })
+);
 var LogoutManagedAuthSessionSetRequest = ManagedAuthOperationIdentity;
-var ManagedAuthLogoutAllReceipt = z.object({
-  generation: z.string().regex(/^[1-9][0-9]*$/),
-  actorEpoch: z.string().regex(/^[1-9][0-9]*$/),
-  state: z.literal("logged_out")
-});
-var ResolveManagedAuthDeepLinkRequest = z.object({
-  path: ManagedAuthReturnIntent
-});
-var ManagedAuthDeepLinkResolution = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("current") }),
-  z.object({ kind: z.literal("switch_required"), slot: ManagedAuthLoginSlot }),
-  z.object({ kind: z.literal("unavailable") })
-]);
-var ManagedAuthSessionSetErrorCode = z.enum([
-  "actor_change_required",
-  "actor_mutation_in_flight",
-  "api_contract_changed",
-  "browser_session_set_required",
-  "browser_session_set_unavailable",
-  "generation_conflict",
-  "invalid_browser_session_set_request",
-  "invalid_transaction",
-  "managed_authentication_required",
-  "managed_authentication_unavailable",
-  "operation_outcome_unknown",
-  "operation_reused",
-  "origin_rejected",
-  "login_transaction_rate_limited",
-  "provider_route_blocked",
-  "slot_limit_reached",
-  "slot_already_exists",
-  "slot_unavailable"
-]);
+var ManagedAuthLogoutAllReceipt = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    generation: z.string().regex(/^[1-9][0-9]*$/),
+    actorEpoch: z.string().regex(/^[1-9][0-9]*$/),
+    state: z.literal("logged_out")
+  })
+);
+var ResolveManagedAuthDeepLinkRequest = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    path: ManagedAuthReturnIntent
+  })
+);
+var ManagedAuthDeepLinkResolution = /* @__PURE__ */ defineSchema(
+  () => z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("current") }),
+    z.object({ kind: z.literal("switch_required"), slot: ManagedAuthLoginSlot }),
+    z.object({ kind: z.literal("unavailable") })
+  ])
+);
+var ManagedAuthSessionSetErrorCode = /* @__PURE__ */ defineSchema(
+  () => z.enum([
+    "actor_change_required",
+    "actor_mutation_in_flight",
+    "api_contract_changed",
+    "browser_session_set_required",
+    "browser_session_set_unavailable",
+    "generation_conflict",
+    "invalid_browser_session_set_request",
+    "invalid_transaction",
+    "managed_authentication_required",
+    "managed_authentication_unavailable",
+    "operation_outcome_unknown",
+    "operation_reused",
+    "origin_rejected",
+    "login_transaction_rate_limited",
+    "provider_route_blocked",
+    "slot_limit_reached",
+    "slot_already_exists",
+    "slot_unavailable"
+  ])
+);
 export {
   BeginManagedAuthLoginTransactionRequest,
   BootstrapManagedAuthSessionSetRequest,