@domino-sdk/relay 0.29.0 → 0.31.0

package/dist/chunk-OQ4ZNOC7.js

@@ -0,0 +1,42 @@
+import {
+  identifier
+} from "./chunk-UPWID5KS.js";
+
+// src/auth.ts
+import { z } from "zod";
+var authScopeSchema = z.object({
+  organization: identifier,
+  project: identifier,
+  environment: z.enum(["test", "live"])
+}).strict();
+var principalSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("member"), member: identifier }).strict(),
+  z.object({ kind: z.literal("staff"), subject: identifier }).strict(),
+  z.object({ kind: z.literal("operator"), subject: identifier }).strict()
+]);
+var sessionSchema = authScopeSchema.extend({
+  id: identifier,
+  principal: principalSchema,
+  expiresAt: z.number()
+});
+var memberSummarySchema = z.object({
+  member: identifier,
+  avatarSeed: z.string().min(1).max(100)
+});
+var exchangeSchema = authScopeSchema.extend({
+  identity: z.object({ issuer: identifier, subject: z.string().min(1).max(200) }).strict(),
+  role: z.enum(["member", "staff", "operator"])
+}).strict();
+var exchangeResultSchema = z.object({
+  token: z.string(),
+  session: sessionSchema
+});
+
+export {
+  authScopeSchema,
+  principalSchema,
+  sessionSchema,
+  memberSummarySchema,
+  exchangeSchema,
+  exchangeResultSchema
+};

package/dist/{chunk-YKS6P4IP.js → chunk-QEN4GHL7.js}

@@ -1,13 +1,13 @@
 import {
   profileSummarySchema
-} from "./chunk-MRKFRCCI.js";
+} from "./chunk-UI4N4XRZ.js";
 import {
   contentMetricSchema,
   contentMetricsSchema,
   identifier,
   pointsRewardSchema,
   tierRewardSchema
-} from "./chunk-BE5V6RFD.js";
+} from "./chunk-UPWID5KS.js";
 
 // src/engagement.ts
 import { z } from "zod";

package/dist/{chunk-LAKQCIHX.js → chunk-UI4N4XRZ.js}

@@ -1,36 +1,147 @@
 import {
   identifier
-} from "./chunk-BE5V6RFD.js";
+} from "./chunk-UPWID5KS.js";
 
-// src/auth.ts
+// src/profiles.ts
 import { z } from "zod";
-var authScopeSchema = z.object({
-  organization: identifier,
-  project: identifier,
-  environment: z.enum(["test", "live"])
-}).strict();
-var principalSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("member"), member: identifier }).strict(),
-  z.object({ kind: z.literal("staff"), subject: identifier }).strict(),
-  z.object({ kind: z.literal("operator"), subject: identifier }).strict()
+var count = z.number().int().nonnegative().safe();
+var profileVisibilitySchema = z.enum([
+  "private",
+  "participants",
+  "public"
+]);
+var avatarProviderSchema = z.enum(["x", "discord", "google"]);
+var profileDefaultProviderSchema = z.enum(["x", "discord"]);
+var profileDefaultsSchema = z.array(profileDefaultProviderSchema).max(profileDefaultProviderSchema.options.length).refine(
+  (providers) => new Set(providers).size === providers.length,
+  "List each provider once"
+);
+var avatarSeedSchema = z.string().min(1).max(100);
+var profileAvatarSchema = z.discriminatedUnion("source", [
+  z.object({
+    source: z.literal("upload"),
+    url: z.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z.object({
+    source: z.literal("account"),
+    provider: avatarProviderSchema,
+    url: z.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z.object({ source: z.literal("generated"), seed: avatarSeedSchema })
 ]);
-var sessionSchema = authScopeSchema.extend({
+var profileSummarySchema = z.object({
   id: identifier,
-  principal: principalSchema,
-  expiresAt: z.number()
+  name: z.string(),
+  avatar: profileAvatarSchema
 });
-var memberSummarySchema = z.object({
-  member: identifier,
-  avatarSeed: z.string().min(1).max(100)
+var invisible = /[\p{Cc}؜᠎​-‏‪-‮⁠-⁤⁦-⁩]/u;
+var displayNameSchema = z.string().max(200).transform((value) => value.normalize("NFC").replace(/\s+/g, " ").trim()).pipe(
+  z.string().min(1, "Enter a name").max(40, "Use at most 40 characters").refine((value) => !invisible.test(value), "Use visible characters only")
+);
+var profileUpdateSchema = z.object({
+  displayName: displayNameSchema.nullable().optional(),
+  avatar: z.discriminatedUnion("source", [
+    z.object({
+      source: z.literal("account"),
+      provider: avatarProviderSchema
+    }).strict(),
+    z.object({ source: z.literal("generated") }).strict()
+  ]).nullable().optional(),
+  hidden: z.boolean().optional()
+}).strict().refine(
+  (value) => Object.values(value).some((field) => field !== void 0),
+  "Change at least one field"
+);
+var ownProfileSchema = profileSummarySchema.extend({
+  /** The name the member chose, or null for the default. */
+  displayName: z.string().nullable(),
+  /** The avatar the member chose: `default` follows the project's defaults. */
+  avatarChoice: z.enum(["default", "upload", "account", "generated"]),
+  /** The account of an `account` choice. */
+  avatarProvider: avatarProviderSchema.nullable(),
+  hidden: z.boolean(),
+  /** An operator locked the name and avatar; the member can still hide the profile. */
+  locked: z.boolean(),
+  /** Who can see profiles in this project, so the app can explain it. */
+  visibility: profileVisibilitySchema,
+  /** The member's connected accounts a picture or name can come from. */
+  options: z.array(
+    z.object({
+      provider: avatarProviderSchema,
+      name: z.string().nullable(),
+      imageUrl: z.string().url().nullable()
+    })
+  )
 });
-var exchangeSchema = authScopeSchema.extend({
-  identity: z.object({ issuer: identifier, subject: z.string().min(1).max(200) }).strict(),
-  role: z.enum(["member", "staff", "operator"])
+var cursor = z.string().min(1).max(512);
+var profileCompletionQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  cursor: cursor.optional()
 }).strict();
-var exchangeResultSchema = z.object({
-  token: z.string(),
-  session: sessionSchema
+var profileCompletionSchema = z.object({
+  quest: identifier,
+  key: identifier.optional(),
+  title: z.string(),
+  completions: count.positive(),
+  /** Null for completions recorded before completion times were. */
+  lastCompletedAt: count.nullable()
+});
+var profileCompletionPageSchema = z.object({
+  items: z.array(profileCompletionSchema),
+  nextCursor: cursor.nullable()
+});
+var profileReferralSchema = z.object({
+  program: identifier,
+  key: identifier.optional(),
+  title: z.string(),
+  /** Members this member invited. Invitations are shared by every program. */
+  invited: count,
+  /** Invited members who qualified in this program. */
+  qualified: count,
+  milestones: z.array(
+    z.object({ id: identifier, count, reached: z.boolean() })
+  )
+});
+var profileSettingsSchema = z.object({
+  visibility: profileVisibilitySchema,
+  defaults: profileDefaultsSchema,
+  revision: count,
+  actor: z.string().nullable(),
+  updatedAt: count.nullable()
 });
+var profileSettingsInputSchema = profileSettingsSchema.omit({ revision: true, actor: true, updatedAt: true }).extend({
+  actionId: identifier,
+  /** The revision the change was made against; a newer one is a 409. */
+  expectedRevision: count,
+  reason: z.string().trim().min(1).max(500)
+}).strict();
+var profileModerationSchema = z.object({
+  actionId: identifier,
+  resetName: z.boolean().default(false),
+  removeAvatar: z.boolean().default(false),
+  /** True locks the name and avatar, false unlocks them. */
+  lock: z.boolean().optional(),
+  reason: z.string().trim().min(1).max(1e3)
+}).strict().refine(
+  (value) => value.resetName || value.removeAvatar || value.lock !== void 0,
+  "Choose an action"
+);
+var managedProfileSchema = ownProfileSchema.omit({ options: true }).extend({
+  member: identifier,
+  lockedAt: count.nullable(),
+  lockedBy: z.string().nullable(),
+  lockedReason: z.string().nullable(),
+  updatedAt: count
+});
+var AVATAR_UPLOAD_LIMIT = 5 * 1024 * 1024;
+var avatarUploadTypes = ["image/jpeg", "image/png", "image/webp"];
+function isProfileParticipantRoute(path, method) {
+  return method === "GET" && (path === "/v1/me/profile" || /^\/v1\/profiles\/[\w-]+(?:\/completions|\/referrals\/[\w-]+)?$/.test(
+    path
+  ) || /^\/v1\/leaderboards\/[\w-]+\/profiles\/[\w-]+$/.test(path)) || method === "POST" && (path === "/v1/me/profile" || path === "/v1/me/profile/avatar");
+}
 
 // src/wallet.ts
 import { z as z2 } from "zod";
@@ -171,8 +282,8 @@ function caip10(wallet, network) {
     return `${wallet.network}:${wallet.address}`;
   }
   const selected = network ?? (wallet.chain === "solana" ? solanaMainnet : "eip155:1");
-  const syntax = wallet.chain === "solana" ? /^solana:[1-9A-HJ-NP-Za-km-z]{32}$/ : /^eip155:[1-9][0-9]{0,15}$/;
-  if (!syntax.test(selected)) {
+  const valid = wallet.chain === "solana" ? /^solana:[1-9A-HJ-NP-Za-km-z]{32}$/.test(selected) : isEvmChainId(selected);
+  if (!valid) {
     throw new Error(`Use a ${wallet.chain} network for this wallet`);
   }
   return `${selected}:${wallet.address}`;
@@ -182,6 +293,13 @@ function isWalletParticipantRoute(path) {
     path
   );
 }
+function isEvmChainId(value) {
+  return /^eip155:[1-9][0-9]{0,15}$/.test(value);
+}
+var evmChainIdSchema = z2.custom(
+  (value) => typeof value === "string" && isEvmChainId(value),
+  'Use an EVM chain ID such as "eip155:8453"'
+);
 var units = z2.string().regex(/^(0|[1-9][0-9]*)$/);
 var walletBalanceSchema = z2.object({
   /** Canonical CAIP-2 ID: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` or `eip155:<chain ID>`. */
@@ -202,12 +320,27 @@ function isWalletSignInRoute(path) {
 }
 
 export {
-  authScopeSchema,
-  principalSchema,
-  sessionSchema,
-  memberSummarySchema,
-  exchangeSchema,
-  exchangeResultSchema,
+  profileVisibilitySchema,
+  avatarProviderSchema,
+  profileDefaultProviderSchema,
+  profileDefaultsSchema,
+  avatarSeedSchema,
+  profileAvatarSchema,
+  profileSummarySchema,
+  displayNameSchema,
+  profileUpdateSchema,
+  ownProfileSchema,
+  profileCompletionQuerySchema,
+  profileCompletionSchema,
+  profileCompletionPageSchema,
+  profileReferralSchema,
+  profileSettingsSchema,
+  profileSettingsInputSchema,
+  profileModerationSchema,
+  managedProfileSchema,
+  AVATAR_UPLOAD_LIMIT,
+  avatarUploadTypes,
+  isProfileParticipantRoute,
   solanaAddressSchema,
   walletConnectionSchema,
   walletChallengeInputSchema,
@@ -233,6 +366,8 @@ export {
   walletSignInNetwork,
   caip10,
   isWalletParticipantRoute,
+  isEvmChainId,
+  evmChainIdSchema,
   walletBalanceSchema,
   isWalletSignInRoute
 };

package/dist/{chunk-BE5V6RFD.js → chunk-UPWID5KS.js}

@@ -91,25 +91,58 @@ var trackerContentSchema = z2.strictObject({
     })
   ])
 });
+var identityKindSchema = z2.enum(["wallet", "x", "discord", "member"]);
+var accountRoleSchema = z2.string().regex(
+  /^[a-zA-Z][a-zA-Z0-9_]{0,39}$/,
+  "Name roles like author or recipient: a letter, then letters, digits or underscores"
+);
+var xAccountRoles = ["author", "inReplyTo"];
+var distinct = (values) => new Set(values).size === values.length;
+var xSearchSourceSchema = z2.object({
+  kind: z2.literal("x-search"),
+  query: z2.string().trim().min(1).max(2e3)
+}).strict();
+var customSourceSchema = z2.object({
+  kind: z2.literal("custom"),
+  namespace: identifier,
+  /**
+   * The identity kinds a record's author and named accounts can be, attributed to members
+   * through verified links. Omitted when authors are opaque IDs, which no quest can pay.
+   */
+  identities: z2.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
+  /** Roles of the named accounts records can carry besides their author, such as `recipient`. */
+  accounts: z2.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
+    (roles) => !roles.includes("author"),
+    "author is every record's own role; name other accounts"
+  ).optional(),
+  /**
+   * How trackers published before identity kinds stored `identities: ["wallet"]`. Reads return
+   * those definitions as stored; write `identities` instead.
+   *
+   * @deprecated Use `identities: ["wallet"]`.
+   */
+  authors: z2.literal("wallet").optional()
+}).strict().refine(
+  (source) => !(source.authors && source.identities),
+  "Use identities, not authors"
+).refine(
+  (source) => !source.accounts || source.identities,
+  "Named accounts need identities"
+);
 var trackerSourceSchema = z2.discriminatedUnion("kind", [
-  z2.object({
-    kind: z2.literal("x-search"),
-    query: z2.string().trim().min(1).max(2e3)
-  }).strict(),
-  z2.object({
-    kind: z2.literal("custom"),
-    namespace: identifier,
-    /**
-     * Record authors are canonical CAIP-10 wallet account IDs, attributed to members through
-     * their verified wallet links. Omitted when authors are opaque IDs.
-     */
-    authors: z2.literal("wallet").optional()
-  }).strict()
+  xSearchSourceSchema,
+  customSourceSchema
 ]);
+function sourceIdentities(source) {
+  if (source.kind === "x-search") {
+    return ["x"];
+  }
+  return source.identities ?? (source.authors === "wallet" ? ["wallet"] : void 0);
+}
 var x = {
-  search: (input) => trackerSourceSchema.options[0].parse({ kind: "x-search", ...input })
+  search: (input) => xSearchSourceSchema.parse({ kind: "x-search", ...input })
 };
-var customSource = (namespace, options = {}) => trackerSourceSchema.options[1].parse({
+var customSource = (namespace, options = {}) => customSourceSchema.parse({
   kind: "custom",
   namespace,
   ...options
@@ -155,14 +188,25 @@ var trackerControlSchema = z2.object({
   actionId: identifier,
   action: z2.enum(["pause", "resume", "refresh"])
 }).strict();
+var trackerAccountSchema = z2.strictObject({
+  kind: identityKindSchema.optional(),
+  id: externalId
+});
 var trackerRecordInputSchema = z2.object({
   id: externalId,
   occurredAt: timestamp,
   observedAt: timestamp,
   author: z2.object({
     id: externalId,
-    verified: z2.boolean().nullable().default(null)
+    verified: z2.boolean().nullable().default(null),
+    /** The author's identity kind; needed when the source names more than one. */
+    kind: identityKindSchema.optional()
   }).strict().nullable().default(null),
+  /** Named accounts besides the author, by the roles the custom source declares. */
+  accounts: z2.record(accountRoleSchema, trackerAccountSchema).refine(
+    (accounts) => Object.keys(accounts).length <= 10,
+    "At most 10 accounts"
+  ).optional(),
   data: z2.record(z2.string(), z2.json()),
   removed: z2.boolean().default(false)
 }).strict().refine(
@@ -182,7 +226,16 @@ var trackerIngestSchema = z2.object({
 var trackerIngestResultSchema = z2.object({
   stored: count,
   /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
-  admissions: z2.object({ admitted: count, skipped: count }).optional()
+  admissions: z2.object({
+    admitted: count,
+    skipped: count,
+    /**
+     * Observations a quest's firing mode selected but its `where` filter did not match, counted
+     * per quest like `admitted` and `skipped`. They record no outcome. Present only when
+     * nonzero.
+     */
+    filtered: count.optional()
+  }).optional()
 });
 var trackerOutcomeFields = {
   /** Stable quest ID. */
@@ -200,10 +253,37 @@ var trackerOutcomeFields = {
   /** Null for automatic decisions; the staff actor after a retry. */
   actor: z2.string().nullable()
 };
+var trackerSkipCodes = [
+  /** The quest is paused or no longer active. */
+  "quest-paused",
+  /** The record occurred before the quest was published. */
+  "before-activation",
+  /** The record is marked removed. */
+  "record-removed",
+  /** The captured X post of this observation cannot be read. */
+  "content-unavailable",
+  /** The record has no account in the beneficiary role, such as a post that is not a reply. */
+  "no-account",
+  /**
+   * The beneficiary account is the record's author account, such as a reply to oneself, or both
+   * belong to the same member. A different account is judged once it resolves to a member, after
+   * `unlinked-account` and `ambiguous-account`.
+   */
+  "beneficiary-is-author",
+  /** No member has verified the beneficiary account. */
+  "unlinked-account",
+  /** More than one member has the beneficiary account. */
+  "ambiguous-account",
+  /** The attributed member has not joined the project. */
+  "not-joined",
+  /** The attributed member has not completed the quest's prerequisites. */
+  "prerequisites-incomplete"
+];
 var trackerOutcomeSchema = z2.discriminatedUnion("state", [
   z2.strictObject({
     ...trackerOutcomeFields,
     state: z2.literal("admitted"),
+    code: z2.null(),
     reason: z2.null(),
     /** The attributed member. */
     member: identifier,
@@ -213,7 +293,9 @@ var trackerOutcomeSchema = z2.discriminatedUnion("state", [
   z2.strictObject({
     ...trackerOutcomeFields,
     state: z2.literal("skipped"),
-    /** Why the observation was skipped. */
+    /** Why the observation was skipped, as one of `trackerSkipCodes`. */
+    code: z2.string().min(1),
+    /** Why the observation was skipped, for people. */
     reason: z2.string(),
     /** The attributed member, when attribution got that far. */
     member: identifier.nullable(),
@@ -226,6 +308,8 @@ var trackerOutcomeQuerySchema = z2.strictObject({
   record: externalId.optional(),
   member: identifier.optional(),
   state: z2.enum(["admitted", "skipped"]).optional(),
+  /** Only skips with this code, such as `unlinked-account`. */
+  code: z2.string().min(1).max(100).optional(),
   limit: z2.coerce.number().int().min(1).max(100).default(25),
   /** Opaque cursor from `next`: older outcomes. */
   before: z2.string().max(512).optional()
@@ -289,7 +373,7 @@ var trackerPreviewLimits = {
   days: 30
 };
 var trackerPreviewInputSchema = z2.object({
-  query: trackerSourceSchema.options[0].shape.query,
+  query: xSearchSourceSchema.shape.query,
   /** Start of the searched window. The window ends when the sample is fetched. */
   since: timestamp
 }).strict();
@@ -499,36 +583,88 @@ var streakProgressSchema = z4.object({
 import { z as z5 } from "zod";
 var timestamp3 = z5.number().int().safe().nonnegative().max(864e13);
 var count2 = z5.number().int().safe().nonnegative();
-var trackerBeneficiarySchema = z5.enum(["author", "replied-to"]);
+var trackerTriggerModeSchema = z5.enum([
+  "new-record",
+  "new-observation",
+  "data-changed"
+]);
+function defaultTriggerMode(source) {
+  return source === "x-search" ? "new-record" : "new-observation";
+}
+var trackerBoundSchema = z5.union([
+  z5.number().finite(),
+  z5.strictObject({ setting: z5.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
+]);
+var dataPath = z5.string().max(200).regex(
+  /^[^.\s]+(\.[^.\s]+)*$/,
+  "Use dot-separated keys, such as metrics.likes"
+);
+var trackerWhereSchema = z5.union([
+  z5.strictObject({
+    path: dataPath,
+    equals: z5.union([z5.string().max(1e3), z5.number().finite(), z5.boolean()])
+  }),
+  z5.strictObject({
+    path: dataPath,
+    gt: trackerBoundSchema.optional(),
+    gte: trackerBoundSchema.optional(),
+    lt: trackerBoundSchema.optional(),
+    lte: trackerBoundSchema.optional()
+  }).refine(
+    (where) => [where.gt, where.gte, where.lt, where.lte].some(
+      (bound) => bound !== void 0
+    ),
+    "Compare with equals, gt, gte, lt or lte"
+  )
+]);
 var trackerTriggerPolicySchema = z5.strictObject({
   /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
   tracker: identifier,
   source: z5.enum(["x-search", "custom"]),
-  beneficiary: trackerBeneficiarySchema
+  /** Which observations fire; absent means the source's default (`defaultTriggerMode`). */
+  on: trackerTriggerModeSchema.optional(),
+  where: trackerWhereSchema.optional(),
+  /**
+   * The record account the quest pays: `author`, `inReplyTo` for an X post, or a named account of
+   * a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
+   * Releases published before account roles store `"replied-to"` for `inReplyTo`.
+   */
+  beneficiary: z5.union([accountRoleSchema, z5.literal("replied-to")])
 });
-var accountId = z5.string().min(5).max(256);
+function triggerMode(policy) {
+  return policy.on ?? defaultTriggerMode(policy.source);
+}
+function beneficiaryRole(policy) {
+  return policy.beneficiary === "replied-to" ? "inReplyTo" : policy.beneficiary;
+}
+var xLink = {
+  issuer: z5.string().min(1),
+  /** The account's stable user ID. */
+  subject: z5.string().min(1).max(256),
+  /** The member's account selection revision. */
+  revision: count2,
+  /** When the member linked the account; null when unknown. */
+  linkedAt: timestamp3.nullable()
+};
 var trackerAttributionSchema = z5.strictObject({
   member: identifier,
   capturedAt: timestamp3,
   account: z5.discriminatedUnion("provider", [
     z5.strictObject({
       provider: z5.literal("wallet"),
-      /** Canonical CAIP-10 account ID, as the record's author. */
-      id: accountId,
+      /** Canonical CAIP-10 account ID, as the record names it. */
+      id: z5.string().min(5).max(256),
       /** The wallet link's revision. */
       revision: count2,
       /** When the member verified the wallet. */
       linkedAt: timestamp3.nullable()
     }),
+    z5.strictObject({ provider: z5.literal("x"), ...xLink }),
+    z5.strictObject({ provider: z5.literal("discord"), ...xLink }),
     z5.strictObject({
-      provider: z5.literal("x"),
-      issuer: z5.string().min(1),
-      /** The X account's stable user ID. */
-      subject: z5.string().min(1).max(256),
-      /** The member's X account selection revision. */
-      revision: count2,
-      /** When the member linked the X account; null when unknown. */
-      linkedAt: timestamp3.nullable()
+      provider: z5.literal("member"),
+      /** The member ID the record names. */
+      id: identifier
     })
   ])
 });
@@ -540,8 +676,10 @@ var trackerTriggerRecordSchema = z5.strictObject({
   firstSeenAt: timestamp3,
   author: z5.strictObject({
     id: z5.string().min(1).max(256),
-    verified: z5.boolean().nullable()
+    verified: z5.boolean().nullable(),
+    kind: identityKindSchema.optional()
   }).nullable(),
+  accounts: z5.record(accountRoleSchema, trackerAccountSchema).optional(),
   data: z5.record(z5.string(), z5.json()),
   removed: z5.boolean()
 });
@@ -550,7 +688,11 @@ var trackerTriggerContextSchema = z5.strictObject({
   tracker: identifier,
   /** The tracker's authoring key. */
   key: identifier,
-  beneficiary: trackerBeneficiarySchema,
+  /**
+   * The record account the attempt pays, as the quest's release names it. Releases published
+   * before account roles name `inReplyTo` `"replied-to"`, which their bundled evaluators expect.
+   */
+  beneficiary: z5.union([accountRoleSchema, z5.literal("replied-to")]),
   record: trackerTriggerRecordSchema,
   /** The captured X post of this observation; null for custom trackers. */
   x: z5.strictObject({
@@ -1525,7 +1667,13 @@ export {
   trackerContentReadSchema,
   trackerEvidenceSchema,
   trackerContentSchema,
+  identityKindSchema,
+  accountRoleSchema,
+  xAccountRoles,
+  xSearchSourceSchema,
+  customSourceSchema,
   trackerSourceSchema,
+  sourceIdentities,
   x,
   customSource,
   trackerDefinitionSchema,
@@ -1534,10 +1682,12 @@ export {
   publishedTrackerSchema,
   trackerStatusSchema,
   trackerControlSchema,
+  trackerAccountSchema,
   trackerRecordInputSchema,
   trackerRecordSchema,
   trackerIngestSchema,
   trackerIngestResultSchema,
+  trackerSkipCodes,
   trackerOutcomeSchema,
   trackerOutcomeQuerySchema,
   trackerOutcomePageSchema,
@@ -1570,8 +1720,13 @@ export {
   streakPolicySchema,
   streak,
   streakProgressSchema,
-  trackerBeneficiarySchema,
+  trackerTriggerModeSchema,
+  defaultTriggerMode,
+  trackerBoundSchema,
+  trackerWhereSchema,
   trackerTriggerPolicySchema,
+  triggerMode,
+  beneficiaryRole,
   trackerAttributionSchema,
   trackerTriggerRecordSchema,
   trackerTriggerContextSchema,