@domino-sdk/relay 0.12.0 → 0.14.0

package/build.d.mts

@@ -1,2 +1,5 @@
 /** Bundle a default-exported quest module without executing it on the build host. */
-export declare function buildQuest(entry: string, options?: {exportName?: string}): Promise<{ code: string }>;
+export declare function buildQuest(
+  entry: string,
+  options?: { exportName?: string }
+): Promise<{ code: string }>

package/build.mjs

@@ -1,12 +1,15 @@
-import { resolve, dirname } from "node:path";
-import { build } from "esbuild";
+import { resolve, dirname } from "node:path"
+import { build } from "esbuild"
+
 /** Bundle an authored quest without evaluating developer code in the build process. */
 export async function buildQuest(entry, options = {}) {
   if (
     options.exportName &&
     !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(options.exportName)
-  )
-    throw new Error("Invalid quest export name");
+  ) {
+    throw new Error("Invalid quest export name")
+  }
+
   const result = await build({
     ...(options.exportName
       ? {
@@ -25,8 +28,12 @@ export async function buildQuest(entry, options = {}) {
     platform: "neutral",
     target: "es2022",
     minify: true,
-  });
-  const file = result.outputFiles[0];
-  if (!file) throw new Error("Quest build produced no module");
-  return { code: file.text };
+  })
+  const file = result.outputFiles[0]
+
+  if (!file) {
+    throw new Error("Quest build produced no module")
+  }
+
+  return { code: file.text }
 }

package/dist/authoring.d.ts

@@ -1,5 +1,5 @@
-import { O as Observation, D as DiscordMember, a as DiscordMessage, W as WalletConnection, S as SolanaBalance, o as observationTriggerSchema, B as Budget, A as AuthoringIdentity, I as IntegrationProvider, b as StreakPolicy } from './settings-B61jIDDA.js';
-export { d as defineLeaderboard, c as defineReferral, e as discord, p as pointLedgers, s as settings, f as streak } from './settings-B61jIDDA.js';
+import { O as Observation, T as TrackerReader, D as DiscordMember, a as DiscordMessage, W as WalletConnection, S as SolanaBalance, o as observationTriggerSchema, B as Budget, A as AuthoringIdentity, I as IntegrationProvider, b as StreakPolicy } from './settings-CU2y-wUM.js';
+export { c as customSource, d as defineLeaderboard, e as defineReferral, f as defineTracker, g as discord, p as pointLedgers, s as settings, h as streak, x } from './settings-CU2y-wUM.js';
 import { z } from 'zod';
 import { PhotoResult, rewardSchema, triggerSchema, QuestPresentation, QuizEvidence, Decision, TieredRewardDefinition } from './schema.js';
 
@@ -137,6 +137,7 @@ type EvaluationContext<T, I = {
     input: I;
     observation: Observation | null;
     eligibleAt: number;
+    trackers: TrackerReader;
     review: {
         photo(options: {
             image: string;
@@ -336,7 +337,7 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
         trigger: {
             kind: "manual";
             input: "photo" | "quiz" | "none";
-            actor?: "member" | "staff" | undefined;
+            actor?: "staff" | "member" | undefined;
         } | {
             kind: "automatic";
             observation?: {

package/dist/authoring.js

@@ -1,8 +1,11 @@
 import {
   authoringKey,
+  customSource,
   defineLeaderboard,
-  defineReferral
-} from "./chunk-CE5XVIJQ.js";
+  defineReferral,
+  defineTracker,
+  x
+} from "./chunk-CJARNIVP.js";
 import {
   budgetSchema,
   decisionSchema,
@@ -19,7 +22,7 @@ import {
   streak,
   tierRewardSchema,
   tieredRewardDefinitionSchema
-} from "./chunk-3UOTI4IU.js";
+} from "./chunk-FUQYKTOJ.js";
 
 // src/authoring.ts
 import { z } from "zod";
@@ -99,18 +102,21 @@ var evaluators = {
         image: ctx.input.photo,
         criteria: config.criteria
       });
-      if (result.kind === "unclear")
+      if (result.kind === "unclear") {
         return config.unclear === "human-review" ? decision.review({ reason: result.reason }) : decision.reject({ reason: result.reason });
+      }
       return result.kind === "pass" ? decision.accept() : decision.reject({ reason: result.reason });
     };
   }
 };
 function defineQuest(definition) {
   const key = authoringKey(definition);
-  if (definition.completion.kind === "streak" && (definition.trigger.kind !== "automatic" || !definition.trigger.observation))
+  if (definition.completion.kind === "streak" && (definition.trigger.kind !== "automatic" || !definition.trigger.observation)) {
     throw new Error("Streaks require an automatic observation trigger");
-  if (definition.trigger.kind === "manual" && definition.trigger.input !== "none" && !definition.evaluate)
+  }
+  if (definition.trigger.kind === "manual" && definition.trigger.input !== "none" && !definition.evaluate) {
     throw new Error("Evidence quests require an evaluator");
+  }
   const fields = Object.fromEntries(
     Object.entries(definition.settings.shape).map(([key2, schema]) => [
       key2,
@@ -164,12 +170,16 @@ function defineQuest(definition) {
         observation: ctx.observation ?? null,
         eligibleAt: ctx.eligibleAt,
         review: ctx.review,
+        trackers: ctx.trackers,
         wallet: ctx.wallet,
         discord: ctx.discord
       }) : decision.accept();
-      if (!result) throw new Error("Evaluator returned no decision");
-      if (result.kind === "review" && !ctx.humanReview)
+      if (!result) {
+        throw new Error("Evaluator returned no decision");
+      }
+      if (result.kind === "review" && !ctx.humanReview) {
         return decisionSchema.parse({ kind: "reject", reason: result.reason });
+      }
       return decisionSchema.parse(
         result.kind === "accept" || result.kind === "review" ? {
           ...result,
@@ -185,12 +195,14 @@ export {
   automatic,
   budget,
   completed,
+  customSource,
   decision,
   defineLeaderboard,
   defineQuest,
   defineQuestType,
   defineReferral,
   defineTieredReward,
+  defineTracker,
   discord,
   discordRole,
   evaluators,
@@ -203,5 +215,6 @@ export {
   settings,
   staffHandover,
   streak,
-  untracked
+  untracked,
+  x
 };

package/dist/browser.d.ts

@@ -1,6 +1,6 @@
 import { SubmitInput, ReviewListOptions, MemberListOptions, ReleaseInput, beginHandoverSchema } from './schema.js';
 import { SubmissionStore, createRelayClient, QuestView, QuestController, ProgressObservation, questExperienceSchema, ProgressObserver, ExchangeInput, PhotoSubmission, QuizSubmission, ClaimSubmission } from './index.js';
-import { r as referralAcceptSchema, L as LeaderboardQuery, w as walletChallengeInputSchema, g as walletProofSchema, h as AuthProvider } from './settings-B61jIDDA.js';
+import { r as referralAcceptSchema, L as LeaderboardQuery, w as walletChallengeInputSchema, i as walletProofSchema, j as AuthProvider } from './settings-CU2y-wUM.js';
 import * as zod from 'zod';
 
 /** Browser client with durable submission recovery; safe to construct during SSR. */

package/dist/browser.js

@@ -1,9 +1,9 @@
 import {
   createRelayClient
-} from "./chunk-NLMEK77N.js";
-import "./chunk-CE5XVIJQ.js";
-import "./chunk-VDWQL6HV.js";
-import "./chunk-3UOTI4IU.js";
+} from "./chunk-YZJOZL4V.js";
+import "./chunk-CJARNIVP.js";
+import "./chunk-I2CCMGN6.js";
+import "./chunk-FUQYKTOJ.js";
 
 // src/browser.ts
 function createBrowserRelayClient(options) {
@@ -15,10 +15,11 @@ function createBrowserRelayClient(options) {
 function browserSubmissionStore() {
   let database;
   function open() {
-    if (!globalThis.indexedDB || !globalThis.navigator?.locks)
+    if (!globalThis.indexedDB || !globalThis.navigator?.locks) {
       throw new Error(
         "This browser cannot safely save submissions. Use a browser with IndexedDB and Web Locks enabled."
       );
+    }
     return database ??= new Promise((resolve, reject) => {
       const request = indexedDB.open("domino-relay-submissions", 1);
       request.onupgradeneeded = () => request.result.createObjectStore("submissions");

package/dist/{chunk-CE5XVIJQ.js → chunk-CJARNIVP.js}

@@ -2,7 +2,7 @@ import {
   identifier,
   pointsRewardSchema,
   tierRewardSchema
-} from "./chunk-3UOTI4IU.js";
+} from "./chunk-FUQYKTOJ.js";
 
 // src/authoring-identity.ts
 import { z } from "zod";
@@ -11,18 +11,20 @@ var authoringIdentityShape = {
   id: identifier.optional()
 };
 function validateAuthoringIdentity(value, ctx) {
-  if (!value.key && !value.id)
+  if (!value.key && !value.id) {
     ctx.addIssue({
       code: "custom",
       path: ["key"],
       message: "Provide an authoring key. Legacy id is also accepted."
     });
-  if (value.key && value.id && value.key !== value.id)
+  }
+  if (value.key && value.id && value.key !== value.id) {
     ctx.addIssue({
       code: "custom",
       path: ["key"],
       message: "id and key must match. Keep the existing authoring name to preserve identity."
     });
+  }
 }
 function normalizeAuthoringIdentity(value) {
   const { id, key, ...properties } = value;
@@ -70,14 +72,18 @@ var referralDefinitionSchema = z2.object({
     }).strict()
   ).max(20).default([])
 }).strict().superRefine((value, ctx) => {
-  for (const entries of [value.milestones, value.bonuses])
-    if (new Set(entries.map((e) => e.id)).size !== entries.length)
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((e) => e.id)).size !== entries.length) {
       ctx.addIssue({ code: "custom", message: "Rule IDs must be unique" });
+    }
+  }
 });
 var referralAuthoringSchema = z2.object(referralDefinitionSchema.shape).omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).superRefine((value, ctx) => {
-  for (const entries of [value.milestones, value.bonuses])
-    if (new Set(entries.map((entry) => entry.id)).size !== entries.length)
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((entry) => entry.id)).size !== entries.length) {
       ctx.addIssue({ code: "custom", message: "Rule keys must be unique" });
+    }
+  }
 }).transform(normalizeAuthoringIdentity);
 function defineReferral(input) {
   const definition = referralAuthoringSchema.parse(input);
@@ -187,18 +193,181 @@ var referralManagementSchema = z2.object({
   next: amount.nullable()
 });
 
-// src/leaderboards.ts
+// src/trackers.ts
 import { z as z3 } from "zod";
-var integer = z3.number().int().safe();
-var timestamp = integer.nonnegative().max(864e13);
-var leaderboardWindowSchema = z3.discriminatedUnion("kind", [
-  z3.object({ kind: z3.literal("all-time") }).strict(),
-  z3.object({ kind: z3.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
-  z3.object({ kind: z3.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+var timestamp = z3.number().int().safe().nonnegative().max(864e13);
+var count = z3.number().int().safe().nonnegative();
+var externalId = z3.string().min(1).max(256);
+var metric = count.nullable().default(null);
+var xTweetSchema = z3.looseObject({
+  id: externalId,
+  userId: externalId,
+  content: z3.string(),
+  createdAt: z3.iso.datetime({ offset: true }),
+  author: z3.looseObject({
+    id: externalId,
+    username: z3.string(),
+    name: z3.string(),
+    verified: z3.boolean().nullable().default(null)
+  }),
+  likeCount: metric,
+  replyCount: metric,
+  retweetCount: metric,
+  quoteCount: metric,
+  viewCount: metric,
+  bookmarkCount: metric,
+  isReply: z3.boolean(),
+  isRetweet: z3.boolean(),
+  isQuoteTweet: z3.boolean()
+});
+var trackerSourceSchema = z3.discriminatedUnion("kind", [
   z3.object({
-    kind: z3.literal("calendar"),
-    period: z3.enum(["day", "week", "month"]),
-    timeZone: z3.string().min(1).max(100).refine((zone) => {
+    kind: z3.literal("x-search"),
+    query: z3.string().trim().min(1).max(2e3)
+  }).strict(),
+  z3.object({ kind: z3.literal("custom"), namespace: identifier }).strict()
+]);
+var x = {
+  search: (input) => trackerSourceSchema.options[0].parse({ kind: "x-search", ...input })
+};
+var customSource = (namespace) => trackerSourceSchema.options[1].parse({ kind: "custom", namespace });
+var windowSchema = z3.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
+  (w) => w.end === void 0 || w.end > w.start,
+  "End must follow start"
+);
+var trackerDefinitionSchema = z3.object({
+  key: identifier,
+  title: z3.string().trim().min(1).max(120),
+  source: trackerSourceSchema,
+  window: windowSchema,
+  refreshSeconds: z3.number().int().min(300).max(86400).default(21600),
+  maxPages: z3.number().int().min(1).max(1e3).default(60)
+}).strict();
+var trackerArtifactSchema = z3.union([
+  trackerDefinitionSchema,
+  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+]);
+function defineTracker(input) {
+  return trackerDefinitionSchema.parse(input);
+}
+var publishedTrackerSchema = z3.object({
+  id: identifier,
+  version: identifier,
+  definition: trackerDefinitionSchema,
+  publishedAt: timestamp,
+  actor: z3.string().nullable()
+});
+var trackerStatusSchema = z3.object({
+  published: publishedTrackerSchema,
+  paused: z3.boolean(),
+  state: z3.enum(["idle", "syncing", "error", "complete"]),
+  lastStartedAt: timestamp.nullable(),
+  lastCompletedAt: timestamp.nullable(),
+  nextSyncAt: timestamp.nullable(),
+  coverage: z3.enum(["unknown", "partial", "complete"]),
+  error: z3.string().nullable(),
+  records: count
+});
+var trackerControlSchema = z3.object({
+  actionId: identifier,
+  action: z3.enum(["pause", "resume", "refresh"])
+}).strict();
+var trackerRecordInputSchema = z3.object({
+  id: externalId,
+  occurredAt: timestamp,
+  observedAt: timestamp,
+  author: z3.object({
+    id: externalId,
+    verified: z3.boolean().nullable().default(null)
+  }).strict().nullable().default(null),
+  data: z3.record(z3.string(), z3.json()),
+  removed: z3.boolean().default(false)
+}).strict().refine(
+  (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
+  "Record exceeds 128 KB"
+);
+var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
+  source: z3.string(),
+  firstSeenAt: timestamp
+});
+var trackerIngestSchema = z3.object({
+  actionId: identifier,
+  records: z3.array(trackerRecordInputSchema).min(1).max(100)
+}).strict();
+var trackerIngestResultSchema = z3.object({ stored: count });
+var booleanQuery = z3.union([
+  z3.boolean(),
+  z3.enum(["true", "false"]).transform((v) => v === "true")
+]);
+var trackerQuerySchema = z3.object({
+  author: externalId.optional(),
+  member: identifier.optional(),
+  verified: booleanQuery.optional(),
+  since: z3.coerce.number().int().safe().nonnegative().optional(),
+  until: z3.coerce.number().int().safe().nonnegative().optional(),
+  removed: booleanQuery.default(false),
+  minLikes: z3.coerce.number().int().safe().nonnegative().optional(),
+  minViews: z3.coerce.number().int().safe().nonnegative().optional(),
+  limit: z3.coerce.number().int().min(1).max(100).default(25),
+  cursor: z3.string().max(2048).optional()
+}).strict().refine(
+  (q) => q.since === void 0 || q.until === void 0 || q.until > q.since,
+  "Until must follow since"
+);
+var trackerPageSchema = z3.object({
+  tracker: identifier,
+  items: z3.array(trackerRecordSchema),
+  nextCursor: z3.string().nullable(),
+  total: count,
+  status: trackerStatusSchema
+});
+var trackerSummarySchema = z3.object({
+  records: count,
+  authors: count,
+  metrics: z3.object({
+    likes: count,
+    replies: count,
+    reposts: count,
+    quotes: count,
+    views: count,
+    bookmarks: count
+  }),
+  missingMetrics: count,
+  status: trackerStatusSchema
+});
+var trackerPreviewLimits = {
+  pages: 3,
+  posts: 100,
+  days: 30
+};
+var trackerPreviewInputSchema = z3.object({
+  query: trackerSourceSchema.options[0].shape.query,
+  /** Start of the searched window. The window ends when the sample is fetched. */
+  since: timestamp
+}).strict();
+var trackerPreviewSchema = z3.object({
+  query: z3.string(),
+  since: timestamp,
+  fetchedAt: timestamp,
+  pages: count,
+  /** Every match in the sample, newest first, verified or not. */
+  posts: z3.array(xTweetSchema).max(trackerPreviewLimits.posts),
+  /** X had more matches than the sample holds. */
+  more: z3.boolean()
+});
+
+// src/leaderboards.ts
+import { z as z4 } from "zod";
+var integer = z4.number().int().safe();
+var timestamp2 = integer.nonnegative().max(864e13);
+var leaderboardWindowSchema = z4.discriminatedUnion("kind", [
+  z4.object({ kind: z4.literal("all-time") }).strict(),
+  z4.object({ kind: z4.literal("fixed"), start: timestamp2, end: timestamp2 }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z4.object({ kind: z4.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  z4.object({
+    kind: z4.literal("calendar"),
+    period: z4.enum(["day", "week", "month"]),
+    timeZone: z4.string().min(1).max(100).refine((zone) => {
       try {
         new Intl.DateTimeFormat("en", { timeZone: zone });
         return true;
@@ -210,22 +379,22 @@ var leaderboardWindowSchema = z3.discriminatedUnion("kind", [
 ]);
 var periodScore = {
   window: leaderboardWindowSchema.default({ kind: "all-time" }),
-  quests: z3.array(identifier).min(1).max(100).optional()
+  quests: z4.array(identifier).min(1).max(100).optional()
 };
-var leaderboardDefinitionSchema = z3.object({
+var leaderboardDefinitionSchema = z4.object({
   id: identifier,
   key: identifier.optional(),
-  title: z3.string().trim().min(1).max(120),
+  title: z4.string().trim().min(1).max(120),
   balance: identifier,
-  score: z3.discriminatedUnion("kind", [
-    z3.object({ kind: z3.literal("balance") }).strict(),
-    z3.object({ kind: z3.literal("earned"), ...periodScore }).strict(),
-    z3.object({
-      kind: z3.literal("net"),
+  score: z4.discriminatedUnion("kind", [
+    z4.object({ kind: z4.literal("balance") }).strict(),
+    z4.object({ kind: z4.literal("earned"), ...periodScore }).strict(),
+    z4.object({
+      kind: z4.literal("net"),
       window: leaderboardWindowSchema.default({ kind: "all-time" })
     }).strict()
   ]).default({ kind: "balance" }),
-  access: z3.enum(["participants", "public"]).default("participants"),
+  access: z4.enum(["participants", "public"]).default("participants"),
   group: identifier.optional()
 }).strict();
 var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
@@ -237,42 +406,42 @@ function defineLeaderboard(input) {
     id: definition.key
   };
 }
-var leaderboardArtifactSchema = z3.union([
+var leaderboardArtifactSchema = z4.union([
   leaderboardAuthoringSchema,
-  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
 ]);
-var publishedLeaderboardSchema = z3.object({
+var publishedLeaderboardSchema = z4.object({
   version: identifier,
   definition: leaderboardDefinitionSchema,
-  publishedAt: timestamp,
-  actor: z3.string().nullable()
+  publishedAt: timestamp2,
+  actor: z4.string().nullable()
 });
-var leaderboardQuerySchema = z3.object({
-  limit: z3.coerce.number().int().min(1).max(100).default(25),
-  cursor: z3.string().max(4096).optional()
+var leaderboardQuerySchema = z4.object({
+  limit: z4.coerce.number().int().min(1).max(100).default(25),
+  cursor: z4.string().max(4096).optional()
 }).strict();
-var leaderboardRowSchema = z3.object({
+var leaderboardRowSchema = z4.object({
   participant: identifier,
   member: identifier.optional(),
-  name: z3.string(),
+  name: z4.string(),
   score: integer,
   rank: integer.positive()
 });
-var leaderboardPageSchema = z3.object({
+var leaderboardPageSchema = z4.object({
   leaderboard: identifier,
-  title: z3.string(),
+  title: z4.string(),
   version: identifier,
-  calculation: z3.enum(["balance", "earned", "net"]),
-  period: z3.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
-  calculatedAt: timestamp,
-  lastEntryAt: timestamp.nullable(),
+  calculation: z4.enum(["balance", "earned", "net"]),
+  period: z4.object({ start: timestamp2.nullable(), end: timestamp2.nullable() }),
+  calculatedAt: timestamp2,
+  lastEntryAt: timestamp2.nullable(),
   total: integer.nonnegative(),
-  items: z3.array(leaderboardRowSchema),
+  items: z4.array(leaderboardRowSchema),
   me: leaderboardRowSchema.nullable(),
-  nearby: z3.array(leaderboardRowSchema),
-  nextCursor: z3.string().nullable()
+  nearby: z4.array(leaderboardRowSchema),
+  nextCursor: z4.string().nullable()
 });
-var leaderboardPreviewSchema = z3.object({
+var leaderboardPreviewSchema = z4.object({
   published: publishedLeaderboardSchema,
   before: leaderboardPageSchema.nullable(),
   after: leaderboardPageSchema
@@ -281,75 +450,75 @@ var mutationBase = {
   actionId: identifier,
   member: identifier,
   balance: identifier,
-  reason: z3.string().trim().min(1).max(1e3)
+  reason: z4.string().trim().min(1).max(1e3)
 };
-var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
-var pointsMutationSchema = z3.discriminatedUnion("kind", [
-  z3.object({
+var datedMutation = { ...mutationBase, effectiveAt: timestamp2.optional() };
+var pointsMutationSchema = z4.discriminatedUnion("kind", [
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("award"),
-    referralEligible: z3.boolean().optional(),
+    kind: z4.literal("award"),
+    referralEligible: z4.boolean().optional(),
     amount: integer.positive()
   }).strict(),
-  z3.object({
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("spend"),
+    kind: z4.literal("spend"),
     amount: integer.positive()
   }).strict(),
-  z3.object({
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("adjust"),
+    kind: z4.literal("adjust"),
     amount: integer.refine((n) => n !== 0)
   }).strict(),
-  z3.object({
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("set"),
+    kind: z4.literal("set"),
     total: integer.nonnegative(),
     expectedTotal: integer.nonnegative(),
-    classification: z3.enum(["earned", "spend"])
+    classification: z4.enum(["earned", "spend"])
   }).strict(),
-  z3.object({
+  z4.object({
     ...mutationBase,
-    kind: z3.literal("reverse"),
+    kind: z4.literal("reverse"),
     entry: identifier,
     amount: integer.positive()
   }).strict()
 ]);
-var pointsEntrySchema = z3.object({
+var pointsEntrySchema = z4.object({
   id: identifier,
-  completion: z3.string().nullable(),
+  completion: z4.string().nullable(),
   member: identifier,
   balance: identifier,
   amount: integer,
-  kind: z3.enum(["award", "spend", "adjust", "reverse"]),
-  effectiveAt: timestamp,
-  receivedAt: timestamp,
+  kind: z4.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp2,
+  receivedAt: timestamp2,
   quest: identifier.nullable(),
   original: identifier.nullable(),
-  reason: z3.string(),
-  actor: z3.string().nullable()
+  reason: z4.string(),
+  actor: z4.string().nullable()
 });
-var pointsResultSchema = z3.object({
+var pointsResultSchema = z4.object({
   entry: pointsEntrySchema,
   total: integer.nonnegative()
 });
-var pointsAccountSchema = z3.object({
+var pointsAccountSchema = z4.object({
   member: identifier,
   balance: identifier,
   total: integer.nonnegative(),
   held: integer.nonnegative()
 });
-var leaderboardExclusionSchema = z3.object({
+var leaderboardExclusionSchema = z4.object({
   actionId: identifier,
   member: identifier,
-  excluded: z3.boolean(),
-  reason: z3.string().trim().min(1).max(1e3)
+  excluded: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
 }).strict();
-var leaderboardGroupSchema = z3.object({
+var leaderboardGroupSchema = z4.object({
   actionId: identifier,
   member: identifier,
-  included: z3.boolean(),
-  reason: z3.string().trim().min(1).max(1e3)
+  included: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
 }).strict();
 
 export {
@@ -369,6 +538,26 @@ export {
   referralSummarySchema,
   referralHistorySchema,
   referralManagementSchema,
+  xTweetSchema,
+  trackerSourceSchema,
+  x,
+  customSource,
+  trackerDefinitionSchema,
+  trackerArtifactSchema,
+  defineTracker,
+  publishedTrackerSchema,
+  trackerStatusSchema,
+  trackerControlSchema,
+  trackerRecordInputSchema,
+  trackerRecordSchema,
+  trackerIngestSchema,
+  trackerIngestResultSchema,
+  trackerQuerySchema,
+  trackerPageSchema,
+  trackerSummarySchema,
+  trackerPreviewLimits,
+  trackerPreviewInputSchema,
+  trackerPreviewSchema,
   leaderboardWindowSchema,
   leaderboardDefinitionSchema,
   leaderboardAuthoringSchema,