@domino-sdk/relay 1.63.0 → 1.66.0

package/dist/chunk-KP2MCX3R.js

@@ -1,587 +0,0 @@
-import {
-  authScopeSchema,
-  exchangeResultSchema
-} from "./chunk-N4BDKS6Y.js";
-import {
-  appIdentityKindSchema,
-  cosmosAddressSchema,
-  cosmosNetworkSchema,
-  evmAddressSchema,
-  identifier,
-  offsetDateTimeSchema,
-  openIdentityKindSchema,
-  solanaAddressSchema
-} from "./chunk-ID3BZXFZ.js";
-
-// src/credential-secrets.ts
-import * as z from "zod";
-var credentialSecretSchema = /* @__PURE__ */ (() => z.object({
-  id: z.string().uuid(),
-  /** The secret's last four characters, to tell secrets apart; null for one issued before hints. */
-  hint: z.string().nullable(),
-  createdAt: z.number(),
-  /** When the secret stops working; null when it never expires. */
-  expiresAt: z.number().nullable(),
-  /** When the secret last authenticated a request; null when it never has. */
-  lastUsedAt: z.number().nullable()
-}))();
-var credentialSecretInputSchema = /* @__PURE__ */ (() => z.object({
-  expiresInDays: z.number().int().min(1).max(3650).optional()
-}).strict())();
-
-// src/server/member-imports.ts
-import * as z2 from "zod";
-var importTimeSchema = /* @__PURE__ */ (() => z2.union([
-  z2.number().int().nonnegative().safe(),
-  offsetDateTimeSchema().transform((value) => Date.parse(value))
-]))();
-var importWalletSchema = /* @__PURE__ */ (() => z2.discriminatedUnion("chain", [
-  z2.object({
-    kind: z2.literal("wallet"),
-    chain: z2.literal("solana"),
-    address: solanaAddressSchema
-  }).strict(),
-  z2.object({
-    kind: z2.literal("wallet"),
-    chain: z2.literal("eip155"),
-    address: evmAddressSchema
-  }).strict(),
-  z2.object({
-    kind: z2.literal("wallet"),
-    chain: z2.literal("cosmos"),
-    network: cosmosNetworkSchema,
-    address: cosmosAddressSchema
-  }).strict()
-]))();
-var importXSchema = /* @__PURE__ */ (() => z2.object({
-  kind: z2.literal("x"),
-  subject: z2.string().regex(/^[1-9][0-9]{0,19}$/, "Use the numeric X user ID")
-}).strict())();
-var importTelegramSchema = /* @__PURE__ */ (() => z2.object({
-  kind: z2.literal("telegram"),
-  subject: z2.string().regex(/^[1-9][0-9]{0,19}$/, "Use the numeric Telegram user ID")
-}).strict())();
-var importDiscordSchema = /* @__PURE__ */ (() => z2.object({
-  kind: z2.literal("discord"),
-  subject: z2.string().regex(/^[1-9][0-9]{0,19}$/, "Use the numeric Discord user ID")
-}).strict())();
-var importAppIdentitySchema = /* @__PURE__ */ (() => z2.object({ kind: appIdentityKindSchema, subject: z2.string().min(1).max(256) }).strict())();
-var memberImportIdentitySchema = /* @__PURE__ */ (() => z2.union([
-  importAppIdentitySchema,
-  importWalletSchema,
-  importXSchema
-]))();
-var memberImportAccountSchema = /* @__PURE__ */ (() => z2.union([
-  importWalletSchema,
-  importXSchema
-]))();
-var memberImportVouchedAccountSchema = /* @__PURE__ */ (() => z2.union([
-  importWalletSchema,
-  importXSchema,
-  importTelegramSchema,
-  importDiscordSchema
-]))();
-var identityReferenceSchema = /* @__PURE__ */ (() => z2.union([
-  importAppIdentitySchema,
-  importWalletSchema,
-  importXSchema,
-  importTelegramSchema,
-  importDiscordSchema
-]))();
-var memberImportActionSchema = /* @__PURE__ */ (() => z2.object({
-  at: importTimeSchema,
-  key: z2.string().min(1).max(200).optional()
-}).strict())();
-var memberImportReferralSchema = /* @__PURE__ */ (() => z2.object({
-  /**
-   * The inviter: the `ref` of another row of this import, or the sign-in identity of a member
-   * who already exists in this environment.
-   */
-  inviter: z2.union([
-    z2.string().trim().min(1).max(200),
-    memberImportIdentitySchema
-  ]),
-  /** When the member accepted the invitation. */
-  acceptedAt: importTimeSchema,
-  /** Referral programs, by authoring key or ID, the member qualified in, and when. */
-  qualified: z2.array(
-    z2.object({ program: z2.string().min(1).max(200), at: importTimeSchema }).strict()
-  ).max(50).default([])
-}).strict())();
-var memberImportConsentSchema = /* @__PURE__ */ (() => z2.object({
-  /** The channel, such as `email`. */
-  channel: z2.string().min(1).max(64),
-  state: z2.enum(["granted", "withdrawn"]),
-  /** When the member chose, on the platform they come from. */
-  at: importTimeSchema,
-  /**
-   * The text the member saw, verbatim: required to grant, at most `consentWordingMaxLength`
-   * characters.
-   */
-  // The 2,000-character limit is a row refusal at check, so a long wording refuses its row
-  // instead of the batch; this bound only caps what a row stores.
-  wording: z2.string().max(8e3).optional()
-}).strict())();
-var memberImportRowSchema = /* @__PURE__ */ (() => z2.object({
-  /** The member's ID on the platform they come from. Unique within an import. */
-  ref: z2.string().trim().min(1).max(200),
-  identity: memberImportIdentitySchema,
-  accounts: z2.array(memberImportAccountSchema).max(20).default([]),
-  /** Opening balances, credited once per ledger as an imported entry. */
-  points: z2.array(
-    z2.object({
-      ledger: z2.string().min(1).max(200),
-      balance: z2.number().int().positive().safe()
-    }).strict()
-  ).max(50).default([]),
-  /** Quest progress, by quest authoring key or ID. */
-  quests: z2.array(
-    z2.object({
-      quest: z2.string().min(1).max(200),
-      actions: z2.array(memberImportActionSchema).min(1).max(3660)
-    }).strict()
-  ).max(200).default([]),
-  referral: memberImportReferralSchema.optional(),
-  /** The member's marketing consent, per channel, as the platform they come from recorded it. */
-  consent: z2.array(memberImportConsentSchema).max(10).optional()
-}).strict())();
-var memberImportFullRowSchema = /* @__PURE__ */ (() => memberImportRowSchema.extend({
-  accounts: z2.array(memberImportVouchedAccountSchema).max(20).default([])
-}).strict())();
-var memberImportCreateSchema = /* @__PURE__ */ (() => z2.object({
-  actionId: identifier,
-  /** Where the members come from, such as "legacy-domino". */
-  source: z2.string().trim().min(1).max(100)
-}).strict())();
-var memberImportRowsInputSchema = /* @__PURE__ */ (() => z2.object({ rows: z2.array(memberImportRowSchema).min(1).max(500) }).strict())();
-var memberImportFullRowsInputSchema = /* @__PURE__ */ (() => z2.object({ rows: z2.array(memberImportFullRowSchema).min(1).max(500) }).strict())();
-var MemberImportRefusalCode = {
-  /** An account or identity belongs to another member in the project. */
-  AccountLinkedElsewhere: "account-linked-elsewhere",
-  /** An operator unlinked the row's app identity. */
-  IdentityUnlinked: "identity-unlinked",
-  /** An earlier row of the import names the same account. */
-  DuplicateAccount: "duplicate-account",
-  /** The row names two X accounts, or the member already has another X account selected. */
-  XAccountSelected: "x-account-selected",
-  /** The row names two Telegram accounts, or the member already has another one selected. */
-  TelegramAccountSelected: "telegram-account-selected",
-  /** The row names two Discord accounts, or the member already has another one selected. */
-  DiscordAccountSelected: "discord-account-selected",
-  /** The member would hold more wallets of a chain family than a member can link. */
-  LimitReached: "limit-reached",
-  UnknownLedger: "unknown-ledger",
-  UnknownQuest: "unknown-quest",
-  /** The quest has no active release in this environment. */
-  QuestNotPublished: "quest-not-published",
-  /** The quest's completions are decided per content item, which an import cannot record. */
-  QuestNotImportable: "quest-not-importable",
-  /** A keyed quest's action has no `key`. */
-  KeyRequired: "key-required",
-  /**
-   * An action's key, on a quest whose keys are unique across members, is used by another member's
-   * completion or by an earlier row of the import.
-   */
-  KeyUsed: "key-used",
-  /** An action, a referral or a consent is dated in the future. */
-  FutureAction: "future-action",
-  /** A consent names a channel Relay does not record consent for. */
-  UnsupportedConsentChannel: "unsupported-consent-channel",
-  /** A granted consent has no wording. */
-  ConsentWordingRequired: "consent-wording-required",
-  /** A consent's wording is longer than `consentWordingMaxLength` characters. */
-  ConsentWordingTooLong: "consent-wording-too-long",
-  /** A consent's wording is not plain text: it has a NUL or a lone surrogate. */
-  ConsentWordingInvalid: "consent-wording-invalid",
-  /** The row's sign-in wallet or X account is linked to its member without sign-in. */
-  SignInDisabled: "sign-in-disabled",
-  /**
-   * The row names one point ledger, quest or referral program twice, by any of its names, or one
-   * consent channel twice.
-   */
-  DuplicateEntry: "duplicate-entry",
-  /** The inviter is no row of this import, and no member of the environment signs in with it. */
-  UnknownInviter: "unknown-inviter",
-  /** The row names its own member as the inviter. */
-  SelfReferral: "self-referral",
-  /** The member already has an inviter. An import never replaces one. */
-  InviterAlreadyAccepted: "inviter-already-accepted",
-  /** The inviter was invited, directly or through others, by this row's member. */
-  ReferralCycle: "referral-cycle",
-  /** The row that names the inviter was refused, so the inviter is never imported. */
-  InviterRefused: "inviter-refused",
-  /** No referral program of that key or ID in this environment, or it is archived. */
-  UnknownReferralProgram: "unknown-referral-program"
-};
-var refusalCodeSchema = /* @__PURE__ */ (() => z2.string())();
-var memberImportRefusalSchema = /* @__PURE__ */ (() => z2.object({
-  code: refusalCodeSchema,
-  message: z2.string()
-}))();
-var memberImportRowResultSchema = /* @__PURE__ */ (() => z2.object({
-  line: z2.number().int().positive(),
-  ref: z2.string(),
-  status: z2.enum(["pending", "ready", "applied", "refused"]),
-  /** The member the row resolves to: an existing member, or the one applying created. */
-  member: identifier.nullable(),
-  /** Whether the row's identity names a member who already exists. Null until checked. */
-  existing: z2.boolean().nullable(),
-  refusals: z2.array(memberImportRefusalSchema),
-  /**
-   * Whether the import's revert went through this applied row. Absent from a Relay older than
-   * this field.
-   */
-  reverted: z2.boolean().optional()
-}))();
-var memberImportRowPageSchema = /* @__PURE__ */ (() => z2.object({
-  items: z2.array(memberImportRowResultSchema),
-  nextCursor: z2.string().nullable()
-}))();
-var memberImportRowQuerySchema = /* @__PURE__ */ (() => z2.object({
-  status: z2.enum(["pending", "ready", "applied", "refused"]).optional(),
-  cursor: z2.string().max(200).optional(),
-  limit: z2.coerce.number().int().min(1).max(500).optional()
-}).strict())();
-var memberImportSummarySchema = /* @__PURE__ */ (() => z2.object({
-  rows: z2.number().int().nonnegative(),
-  ready: z2.number().int().nonnegative(),
-  refused: z2.number().int().nonnegative(),
-  members: z2.object({
-    created: z2.number().int().nonnegative(),
-    existing: z2.number().int().nonnegative()
-  }),
-  /** Identities and accounts the ready rows attach, sign-in identities included. */
-  accounts: z2.number().int().nonnegative(),
-  /** Opening balance totals, by ledger as the rows name it. */
-  points: z2.array(
-    z2.object({ ledger: z2.string(), total: z2.number().int().nonnegative() })
-  ),
-  /** Imported actions, by quest as the rows name it. */
-  actions: z2.array(
-    z2.object({ quest: z2.string(), total: z2.number().int().nonnegative() })
-  ),
-  /**
-   * Accepted referrals the ready rows record, and their qualifications by program as the rows
-   * name it. Absent from a summary written before imports carried referrals.
-   */
-  referrals: z2.object({
-    accepted: z2.number().int().nonnegative(),
-    qualified: z2.array(
-      z2.object({
-        program: z2.string(),
-        total: z2.number().int().nonnegative()
-      })
-    )
-  }).optional(),
-  /** Refused rows, by refusal code. A row can have several. */
-  refusals: z2.array(
-    z2.object({ code: refusalCodeSchema, rows: z2.number().int().nonnegative() })
-  )
-}))();
-var memberImportCommandSchema = /* @__PURE__ */ (() => z2.object({ actionId: identifier.optional() }).strict())();
-var memberImportRevertInputSchema = /* @__PURE__ */ (() => z2.object({
-  actionId: identifier,
-  reason: z2.string().trim().min(1).max(500)
-}).strict())();
-var memberImportRevertOutcomeSchema = /* @__PURE__ */ (() => z2.object({
-  reversed: z2.object({
-    /** Applied rows the revert went through. */
-    rows: z2.number().int().nonnegative(),
-    /** Opening balance entries reversed. */
-    entries: z2.number().int().nonnegative(),
-    /** Imported completions revoked. */
-    completions: z2.number().int().nonnegative(),
-    /** Links the rows created that the revert removed. */
-    links: z2.number().int().nonnegative()
-  }),
-  /**
-   * Imported points the revert could not take back, by member and point ledger: the member had
-   * spent or reserved them. A revert takes only free points, as a completion's revocation does,
-   * so no balance goes below zero and Relay records no debt.
-   */
-  unreversedPoints: z2.array(
-    z2.object({
-      member: identifier,
-      ledger: identifier,
-      amount: z2.number().int().positive()
-    })
-  ),
-  /**
-   * Links the rows created that stay, because the member relied on them since: `signed-in` with
-   * it, or `proved` a vouched wallet. `kind` is `wallet`, the provider (`x`, `telegram`,
-   * `discord`) or `app:<name>`; `account` is the address or subject. A row whose member was erased
-   * (`members.erase`) is passed over whole: one entry with `kind: "member"`, the member ID as
-   * `account` and reason `member-erased`, and nothing of that row is reversed.
-   */
-  keptLinks: z2.array(
-    z2.object({
-      member: identifier,
-      kind: z2.string(),
-      account: z2.string(),
-      reason: z2.string()
-    })
-  ),
-  /**
-   * True when rows were applied before imports recorded the links they created: those rows'
-   * links all stay, and only their balances and completions were reversed.
-   */
-  linksUntracked: z2.boolean()
-}))();
-var memberImportRevertSchema = /* @__PURE__ */ (() => z2.object({
-  reason: z2.string(),
-  requestedAt: z2.number().int(),
-  requestedBy: z2.string().nullable(),
-  /** Applied rows reverted so far. */
-  rows: z2.number().int().nonnegative(),
-  revertedAt: z2.number().int().nullable(),
-  outcome: memberImportRevertOutcomeSchema.nullable()
-}))();
-var MemberImportState = {
-  /** Rows are being added. */
-  Open: "open",
-  /** The check (the dry run) is running. */
-  Checking: "checking",
-  /** Checked, with a summary; it can be applied. */
-  Checked: "checked",
-  /** Applying its ready rows, in the background. */
-  Applying: "applying",
-  /** Every ready row was applied or refused. */
-  Applied: "applied",
-  /** Stopped while applying: the rows it did not reach stay `ready`, and it can't be applied again. */
-  Stopped: "stopped",
-  /** Its revert is taking back what its applied rows granted, in the background. */
-  Reverting: "reverting",
-  /** Its revert went through every applied row. */
-  Reverted: "reverted",
-  /** Canceled before it was applied. */
-  Canceled: "canceled"
-};
-var memberImportStateSchema = /* @__PURE__ */ (() => z2.string())();
-var memberImportSchema = /* @__PURE__ */ (() => z2.object({
-  id: identifier,
-  source: z2.string(),
-  /**
-   * The import's state, open to states Relay adds. Absent from a Relay older than this field;
-   * `status` then holds the state, folded as below.
-   */
-  state: memberImportStateSchema.optional(),
-  /**
-   * The state as SDK 1.0 typed it: `applied` for a stopped, reverting or reverted import too, so
-   * filtering on `applied` includes them. Read `state` instead.
-   */
-  status: z2.enum([
-    "open",
-    "checking",
-    "checked",
-    "applying",
-    "applied",
-    "canceled"
-  ]),
-  rows: z2.number().int().nonnegative(),
-  /** The latest check's summary, or null before the first check and after rows change. */
-  summary: memberImportSummarySchema.nullable(),
-  /** While applying and after, stopped included: rows applied and refused so far. */
-  progress: z2.object({
-    applied: z2.number().int().nonnegative(),
-    refused: z2.number().int().nonnegative()
-  }),
-  createdAt: z2.number().int(),
-  createdBy: z2.string().nullable(),
-  checkedAt: z2.number().int().nullable(),
-  appliedAt: z2.number().int().nullable(),
-  appliedBy: z2.string().nullable(),
-  canceledAt: z2.number().int().nullable(),
-  canceledBy: z2.string().nullable(),
-  /** Set when the import was stopped while applying; `appliedAt` stays null. */
-  stoppedAt: z2.number().int().nullish(),
-  stoppedBy: z2.string().nullish(),
-  /** Set once a revert was asked for: the import is `reverting`, then `reverted`. */
-  revert: memberImportRevertSchema.nullish()
-}))();
-var memberImportPageSchema = /* @__PURE__ */ (() => z2.object({
-  items: z2.array(memberImportSchema),
-  nextCursor: z2.string().nullable()
-}))();
-var memberImportListQuerySchema = /* @__PURE__ */ (() => z2.object({
-  cursor: z2.string().max(200).optional(),
-  limit: z2.coerce.number().int().min(1).max(100).optional()
-}).strict())();
-
-// src/identity-integration.ts
-import * as z3 from "zod";
-var identityIntegrationInputSchema = /* @__PURE__ */ (() => z3.object({
-  name: z3.string().trim().min(1).max(80),
-  origin: z3.string().url().superRefine((value, context) => {
-    const url = new URL(value);
-    if (url.protocol !== "https:") {
-      context.addIssue({ code: "custom", message: "Use an HTTPS origin." });
-    } else if (url.origin !== value) {
-      context.addIssue({
-        code: "custom",
-        message: `Use the exact origin ${url.origin}, without a path, query or trailing slash.`
-      });
-    }
-  }),
-  /**
-   * The identity kind this integration owns in the project and environment, such as
-   * `app:game`. Each member it signs in gets the exchanged subject as an identity of this
-   * kind, which tracker attribution and `ctx.member.identities()` read. Its kind cannot change.
-   * Omit it for an integration that only signs members in.
-   *
-   * A kind belongs to the integration that first claimed it, also after that integration is
-   * disconnected. A new integration takes a kind that already has identities only by adopting
-   * them with `adoptIdentitiesFrom`.
-   */
-  identityKind: appIdentityKindSchema.optional(),
-  /**
-   * Adopt the identities of a disconnected integration's `identityKind`: its ID, as
-   * `identityIntegrations.kinds()` lists it. Adopt only when this app's user IDs mean the same
-   * users as that integration's, because each one then signs in as the member that ID is linked
-   * to. Needs `reason`, which the audit log keeps.
-   */
-  adoptIdentitiesFrom: z3.string().uuid().optional(),
-  /** Why the identities are adopted; required with `adoptIdentitiesFrom`. */
-  reason: z3.string().trim().min(1).max(500).optional(),
-  /** Days until the first secret expires. Omit it for a key that never expires. */
-  expiresInDays: z3.number().int().min(1).max(3650).optional()
-}).strict().refine(
-  (input) => !input.adoptIdentitiesFrom || input.identityKind,
-  "Adopting identities needs the identityKind they have"
-).refine(
-  (input) => !input.adoptIdentitiesFrom === !input.reason,
-  "Give a reason when adopting identities, and only then"
-))();
-var identityIntegrationSchema = /* @__PURE__ */ (() => z3.object({
-  ...authScopeSchema.shape,
-  id: z3.string().uuid(),
-  name: z3.string(),
-  origin: z3.string(),
-  /**
-   * When the integration's last working secret expires: 8640000000000000 (the latest date
-   * JavaScript represents) when one never does.
-   *
-   * @deprecated Read `secrets`, which gives each secret's own expiry.
-   */
-  expiresAt: z3.number(),
-  /** The integration's working secrets, oldest first. Any of them authenticates it. */
-  secrets: z3.array(credentialSecretSchema).default([]),
-  /** The latest use of any of its secrets, revoked ones included; null when none was used. */
-  lastUsedAt: z3.number().nullable().default(null),
-  /** The identity kind the integration owns; null when it only signs members in. */
-  identityKind: openIdentityKindSchema.nullable().default(null),
-  /**
-   * Whether the app's server may vouch for its members' accounts when it signs them in
-   * (`accounts` on the exchange). False in Relay versions without it.
-   */
-  vouchesAccounts: z3.boolean().default(false)
-}))();
-var identityIntegrationSecretSchema = /* @__PURE__ */ (() => identityIntegrationSchema.extend(
-  {
-    token: z3.string()
-  }
-))();
-var identityKindClaimSchema = /* @__PURE__ */ (() => z3.object({
-  kind: openIdentityKindSchema,
-  /** The owning integration's ID; it stays after the integration is disconnected. */
-  integration: z3.string(),
-  /** The owning integration's name when it claimed or adopted the kind. */
-  integrationName: z3.string(),
-  /** Whether the owning integration is still connected. */
-  connected: z3.boolean(),
-  /** Linked identities of the kind; adopting them is required to reuse the kind. */
-  linked: z3.number().int().nonnegative(),
-  /** Identities an operator unlinked. */
-  unlinked: z3.number().int().nonnegative(),
-  claimedAt: z3.number().int().nonnegative()
-}))();
-var identityIntegrationAccountVouchingInputSchema = /* @__PURE__ */ (() => z3.object({
-  enabled: z3.boolean(),
-  reason: z3.string().trim().min(1).max(500),
-  actionId: identifier.optional()
-}).strict())();
-var vouchedProviders = ["x", "telegram", "discord"];
-var participantExchangeAccountsSchema = /* @__PURE__ */ (() => z3.array(memberImportVouchedAccountSchema).max(20).refine(
-  (accounts) => vouchedProviders.every(
-    (kind) => accounts.filter((entry) => entry.kind === kind).length <= 1
-  ),
-  "Vouch for at most one X, Telegram and Discord account each"
-))();
-var participantExchangeSchema = /* @__PURE__ */ (() => z3.object({
-  subject: z3.string().min(1).max(200),
-  previousToken: z3.string().max(200).optional(),
-  /**
-   * Accounts the app vouches belong to this member, attached on the organization's word like an
-   * import's. Needs an integration with `vouchesAccounts`; otherwise the exchange is refused with
-   * `ACCOUNT_VOUCHING_OFF`.
-   */
-  accounts: participantExchangeAccountsSchema.optional()
-}).strict())();
-var participantExchangeAccountResultSchema = /* @__PURE__ */ (() => z3.object({
-  account: memberImportVouchedAccountSchema,
-  status: z3.string(),
-  code: z3.string().optional(),
-  message: z3.string().optional()
-}))();
-var participantExchangeResultSchema = /* @__PURE__ */ (() => exchangeResultSchema.extend({
-  accounts: z3.array(participantExchangeAccountResultSchema).optional()
-}))();
-var identityIntegrationKeySchema = /* @__PURE__ */ (() => z3.object({
-  id: z3.string(),
-  name: z3.string(),
-  organization: z3.string(),
-  project: z3.string(),
-  environment: z3.string(),
-  origin: z3.string(),
-  identityKind: openIdentityKindSchema.nullable().default(null),
-  vouchesAccounts: z3.boolean().default(false),
-  secretExpiresAt: z3.number().nullable().default(null),
-  appOrigins: z3.array(z3.string()).default([])
-}))();
-var accountVouchedBySchema = /* @__PURE__ */ (() => z3.object({
-  /** The integration's ID; it stays after the integration is disconnected. */
-  integration: z3.string(),
-  /** The integration's name when it vouched for the account. */
-  integrationName: z3.string()
-}))();
-
-export {
-  credentialSecretSchema,
-  credentialSecretInputSchema,
-  memberImportIdentitySchema,
-  memberImportAccountSchema,
-  memberImportVouchedAccountSchema,
-  identityReferenceSchema,
-  memberImportActionSchema,
-  memberImportReferralSchema,
-  memberImportConsentSchema,
-  memberImportRowSchema,
-  memberImportFullRowSchema,
-  memberImportCreateSchema,
-  memberImportRowsInputSchema,
-  memberImportFullRowsInputSchema,
-  MemberImportRefusalCode,
-  memberImportRefusalSchema,
-  memberImportRowResultSchema,
-  memberImportRowPageSchema,
-  memberImportRowQuerySchema,
-  memberImportSummarySchema,
-  memberImportCommandSchema,
-  memberImportRevertInputSchema,
-  memberImportRevertOutcomeSchema,
-  memberImportRevertSchema,
-  MemberImportState,
-  memberImportSchema,
-  memberImportPageSchema,
-  memberImportListQuerySchema,
-  identityIntegrationInputSchema,
-  identityIntegrationSchema,
-  identityIntegrationSecretSchema,
-  identityKindClaimSchema,
-  identityIntegrationAccountVouchingInputSchema,
-  participantExchangeAccountsSchema,
-  participantExchangeSchema,
-  participantExchangeAccountResultSchema,
-  participantExchangeResultSchema,
-  identityIntegrationKeySchema,
-  accountVouchedBySchema
-};

package/dist/chunk-N4BDKS6Y.js

@@ -1,87 +0,0 @@
-import {
-  identifier
-} from "./chunk-ID3BZXFZ.js";
-
-// src/auth.ts
-import * as z from "zod";
-var authScopeSchema = /* @__PURE__ */ (() => z.object({
-  organization: identifier,
-  project: identifier,
-  environment: z.enum(["test", "live"])
-}).strict())();
-var principalSchema = /* @__PURE__ */ (() => z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("member"), member: identifier }),
-  z.object({ kind: z.literal("staff"), subject: identifier }),
-  z.object({ kind: z.literal("operator"), subject: identifier })
-]))();
-var sessionSchema = /* @__PURE__ */ (() => z.object({
-  ...authScopeSchema.shape,
-  id: identifier,
-  principal: principalSchema,
-  expiresAt: z.number()
-}))();
-var knownPrincipalKinds = /* @__PURE__ */ (() => principalSchema.options.map(
-  (option) => option.shape.kind.value
-))();
-var participantPrincipalSchema = /* @__PURE__ */ (() => z.union([
-  principalSchema,
-  z.object({ kind: z.string().min(1) }).refine((principal) => !knownPrincipalKinds.includes(principal.kind))
-]))();
-var participantSessionSchema = /* @__PURE__ */ (() => z.object({
-  ...authScopeSchema.shape,
-  id: identifier,
-  principal: participantPrincipalSchema,
-  expiresAt: z.number()
-}))();
-function sessionMember(session) {
-  const principal = session?.principal;
-  return principal?.kind === "member" && "member" in principal ? principal.member : null;
-}
-var memberSummarySchema = /* @__PURE__ */ (() => z.object({
-  member: identifier,
-  avatarSeed: z.string().min(1).max(100),
-  /**
-   * The member's own email address for "signed in as": the first of `emails`, or null when they
-   * have none, such as after wallet-only sign-in. Only the member reads it. Relay always sends
-   * it; the SDK reads one older than this field as null.
-   */
-  email: z.string().min(1).nullable().default(null),
-  /**
-   * The verified email addresses that sign the member in: each email-code sign-in address, then
-   * the verified email of each Google or Apple account enabled for sign-in. Accounts connected
-   * only for activity are left out. Empty when there are none, and read as empty from a Relay
-   * older than this field.
-   */
-  emails: z.array(z.string().min(1)).default([]),
-  /**
-   * The member's clock, which Relay judges their activity on. `now` is their current time in epoch
-   * milliseconds and `offsetMs` how far it runs ahead of real time: a test member's clock moves
-   * when the staging toolbar or `domino test-members advance` moves it, and every other member's
-   * offset is 0. `memberTime()` keeps it ticking. Absent from a Relay older than this field;
-   * `relay.me.get()` then answers real time.
-   */
-  clock: z.object({
-    now: z.number().int().nonnegative(),
-    offsetMs: z.number().int()
-  }).optional()
-}))();
-var exchangeSchema = /* @__PURE__ */ (() => authScopeSchema.extend({
-  identity: z.object({ issuer: identifier, subject: z.string().min(1).max(200) }).strict(),
-  role: z.enum(["member", "staff", "operator"])
-}).strict())();
-var exchangeResultSchema = /* @__PURE__ */ (() => z.object({
-  token: z.string(),
-  session: sessionSchema
-}))();
-
-export {
-  authScopeSchema,
-  principalSchema,
-  sessionSchema,
-  participantPrincipalSchema,
-  participantSessionSchema,
-  sessionMember,
-  memberSummarySchema,
-  exchangeSchema,
-  exchangeResultSchema
-};