@domino-sdk/relay 1.0.0-next.3 → 1.0.0-next.34

package/dist/authoring.d.ts

@@ -1,20 +1,474 @@
-import { A as AdmittedContent, O as Observation, T as TrackerTriggerContext, a as TrackerReader, X as XReader, I as ImageReader, D as DiscordMember, b as DiscordMessage, W as WalletConnection, S as SolanaBalance, L as LinkedWallet, c as WalletBalanceQuery, d as WalletBalance, e as TrackerDefinition, f as TrackerTriggerMode, g as TrackerWhere, o as observationTriggerSchema, h as TrackerTriggerPolicy, B as Budget, i as AuthoringIdentity, C as ContentMetric, j as IntegrationProvider, k as StreakPolicy, l as TextEvidence, U as UrlEvidence, m as TextOptions, n as UrlOptions } from './submission-input-jVvTh4Ed.js';
-export { E as EvmChainId, p as content, q as customSource, r as defineEngagementReward, s as defineLeaderboard, t as defineReferral, u as defineTracker, v as discord, w as formatUnits, x as isEvmChainId, y as parseUnits, z as perContent, F as pointLedgers, G as settings, H as streak, J as trackerTriggerContextSchema, K as x } from './submission-input-jVvTh4Ed.js';
+import { cB as xContentBodySchema, I as IdentityKind, aM as customSourceSchema, at as WithRecordData, as as WithContent, ar as WithAccountRoles, cG as QuestHandle, cH as LedgerReference, cI as GroupHandle, cF as ResourceHandle, ad as TrackerSource, c1 as trackerDefinitionSchema, U as Tracker, $ as TrackerData, H as SourceRoles, cJ as LedgerHandle, cD as xSearchSourceSchema, av as XTweet, au as XContentMetric, aj as TrackerTriggerPolicy, ap as Where, r as MemberIdentity, ah as TrackerTriggerContext, ab as TrackerReader, L as TextReviewInput, J as TextResult, P as PhotoResult, n as Decision, by as rewardSchema, ai as TrackerTriggerMode, F as RoleOf, aq as WhereSetting, k as ContentBody, l as ContentMetricName, cw as triggerSchema, d as QuestPresentation, e as QuestProfile, f as QuizEvidence, N as TieredRewardDefinition } from './schema-DfJzH2ci.js';
+export { cK as LedgerSetting, a1 as TrackerDataSchema, a6 as TrackerPage, aa as TrackerReadQuery, cL as trackerDataSchema, cn as trackerTriggerContextSchema } from './schema-DfJzH2ci.js';
 import { z } from 'zod';
-import { TextReviewInput, TextResult, PhotoResult, rewardSchema, triggerSchema, QuestPresentation, QuestProfile, QuizEvidence, Decision, TieredRewardDefinition } from './schema.js';
+export { z } from 'zod';
+import { E as EngagementBudget, a4 as leaderboardDefinitionSchema, aQ as AuthoringIdentity, au as pointLedgerDeclarationSchema, aJ as referralAuthoringSchema, C as CampaignDefinition, A as AvailabilityWindow } from './groups-Ck-OxzjD.js';
+export { G as defineCampaign, H as defineGroup } from './groups-Ck-OxzjD.js';
+import { u as discordMessagesSourceSchema, e as DiscordMessageData, f as DiscordMessageTextData, w as discordReactionsSourceSchema, g as DiscordReactionData, h as DiscordReader, P as Prerequisite, T as TextEvidence, U as UrlEvidence, b as TextOptions, c as UrlOptions } from './submission-input-BZkm6ohU.js';
+export { k as balanceAtLeast, m as completed, B as inGroup } from './submission-input-BZkm6ohU.js';
+import { Q as QuizContent, a as StreakPolicy } from './streaks-CWyq8Px5.js';
+import { d as ResourceSource, S as Setting, b as IntegrationModule, i as XReader, B as Budget, I as IntegerSettings } from './capability-error-DNMwKmlL.js';
+export { L as CapabilityError, C as CapabilityErrorCode, k as capabilityErrorCodes } from './capability-error-DNMwKmlL.js';
+import { e as ImageReader } from './images-Dv-P5VBw.js';
+export { e as defineOffer } from './offers-Cy-e4o5x.js';
+import { l as WalletReader } from './wallet-YssWxGg8.js';
+export { h as CosmosDenom, a as CosmosNetwork, E as EvmChainId, j as WalletBalance, k as WalletBalanceQuery, p as cosmosDenomSchema, q as cosmosNetworkSchema, t as isEvmChainId } from './wallet-YssWxGg8.js';
+export { f as formatUnits, p as parseUnits } from './units-CwgsPB_r.js';
+
+declare function defineLedger(input: z.input<typeof pointLedgerDeclarationSchema>): {
+    name: string;
+    description: string;
+    key: string;
+} & ResourceHandle<"ledger">;
+/** One independent cumulative formula; management changes capture a new scoring boundary. */
+declare function defineEngagementReward<const M extends readonly [string, ...string[]]>(input: {
+    key: string;
+    qualifiedBy: QuestHandle;
+    ledger: LedgerReference;
+    metrics: M;
+    baseline: "historical";
+    maxAgeMs?: number;
+    budgets?: EngagementBudget[];
+    target: (input: {
+        metrics: Record<M[number], number>;
+    }) => number;
+}): {
+    key: string;
+    describe: () => {
+        key: string;
+        qualifiedBy: string;
+        balance: string;
+        metrics: string[];
+        baseline: "historical";
+        maxAgeMs: number;
+        budgets: {
+            scope: "member" | "project";
+            period: "lifetime" | "day" | "week" | "month";
+            limit: number;
+        }[];
+    };
+    score(raw: unknown): {
+        target: number;
+        baseline: number;
+    };
+};
+/**
+ * One milestone per quest, after `days` consecutive project calendar days with an accepted
+ * attempt. Multiple accepted attempts occupy one day. The day comes from the attempt's trusted
+ * occurrence time: a tracker record's `occurredAt` for `automatic({ tracker })`, and the
+ * submission's admission time for `manual()`, so a manual streak counts the days a member
+ * submitted. Days begin at midnight in the project timezone (`calendar.timeZone` in relay.json, or
+ * Console settings). Not available on content quests or prerequisite-only `automatic()`.
+ */
+declare const streak: (options: {
+    days: number;
+}) => StreakPolicy;
+/** The number of distinct qualifying actions in one counter achievement. */
+declare const count: (count: number) => {
+    kind: "count";
+    count: number;
+} & z.core.$brand<"counter-goal">;
+/** A counter window in the shared project calendar, with a bounded lateness allowance. */
+declare const calendar: (period: "day" | "week" | "month", options?: {
+    latenessMs?: number;
+}) => ({
+    kind: "lifetime";
+} & z.core.$brand<"counter-window">) | ({
+    kind: "calendar";
+    period: "day" | "week" | "month";
+    latenessMs: number;
+} & z.core.$brand<"counter-window">) | ({
+    kind: "rolling";
+    durationMs: number;
+} & z.core.$brand<"counter-window">);
+/** A trailing elapsed-time window, independent of timezone and calendar boundaries. */
+declare const rolling: ({ days }: {
+    days: number;
+}) => ({
+    kind: "lifetime";
+} & z.core.$brand<"counter-window">) | ({
+    kind: "calendar";
+    period: "day" | "week" | "month";
+    latenessMs: number;
+} & z.core.$brand<"counter-window">) | ({
+    kind: "rolling";
+    durationMs: number;
+} & z.core.$brand<"counter-window">);
+declare const questCompleted: (quest: QuestHandle) => {
+    kind: "quest";
+    quest: QuestHandle;
+};
+type ReferralInput = z.input<typeof referralAuthoringSchema>;
+type ReferralBonus = NonNullable<ReferralInput["bonuses"]>[number];
+type ReferralMilestone = NonNullable<ReferralInput["milestones"]>[number];
+declare function defineReferral(input: Omit<ReferralInput, "qualification" | "inviterGroup" | "milestones" | "bonuses"> & {
+    qualification: {
+        kind: "signup" | "external";
+    } | ReturnType<typeof questCompleted>;
+    inviterGroup?: GroupHandle;
+    milestones?: (Omit<ReferralMilestone, "id"> & {
+        key: string;
+    })[];
+    bonuses?: (Omit<ReferralBonus, "id" | "balance" | "quests"> & {
+        key: string;
+        ledger: LedgerReference;
+        quests?: QuestHandle[];
+    })[];
+}): {
+    title: string;
+    rewards: {
+        inviter: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                } | {
+                    kind: "automatic";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+        invitee: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                } | {
+                    kind: "automatic";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+    };
+    qualification: {
+        kind: "signup";
+    } | {
+        kind: "quest";
+        quest: string;
+    } | {
+        kind: "external";
+    };
+    enabled: boolean;
+    milestones: {
+        id: string;
+        count: number;
+        rewards: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                } | {
+                    kind: "automatic";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+    }[];
+    bonuses: {
+        id: string;
+        balance: string;
+        basisPoints: number;
+        external: boolean;
+        quests?: string[] | undefined;
+        durationDays?: number | undefined;
+        maxPoints?: number | undefined;
+    }[];
+    key: string;
+    inviterGroup?: string | undefined;
+} & ResourceHandle<"referral">;
+type LeaderboardInput = z.input<typeof leaderboardDefinitionSchema>;
+type EarnedScore = Extract<NonNullable<LeaderboardInput["score"]>, {
+    kind: "earned";
+}>;
+declare function earned(options?: Omit<EarnedScore, "kind" | "quests"> & {
+    quests?: QuestHandle[];
+}): {
+    window?: {
+        kind: "fixed";
+        start: number;
+        end: number;
+    } | {
+        kind: "all-time";
+    } | {
+        kind: "rolling";
+        days: number;
+    } | {
+        kind: "calendar";
+        period: "day" | "week" | "month";
+    } | undefined;
+    quests?: QuestHandle[];
+    kind: "earned";
+};
+declare function defineLeaderboard(input: Omit<LeaderboardInput, "key" | "id" | "balance" | "group" | "score"> & AuthoringIdentity & {
+    ledger: LedgerReference;
+    group?: GroupHandle;
+    score?: Exclude<LeaderboardInput["score"], {
+        kind: "earned";
+    }> | ReturnType<typeof earned>;
+}): {
+    title: string;
+    balance: string;
+    access: "participants" | "public";
+    score: {
+        kind: "balance";
+    } | {
+        window: {
+            kind: "fixed";
+            start: number;
+            end: number;
+        } | {
+            kind: "all-time";
+        } | {
+            kind: "rolling";
+            days: number;
+        } | {
+            kind: "calendar";
+            period: "day" | "week" | "month";
+        };
+        kind: "earned";
+        quests?: string[] | undefined;
+    } | {
+        kind: "net";
+        window: {
+            kind: "fixed";
+            start: number;
+            end: number;
+        } | {
+            kind: "all-time";
+        } | {
+            kind: "rolling";
+            days: number;
+        } | {
+            kind: "calendar";
+            period: "day" | "week" | "month";
+        };
+    };
+    key: string;
+    settle?: {
+        at: "window-end";
+        ties: "shared" | "earliest";
+        prizes: {
+            ranks: [number, number];
+            rewards: ({
+                kind: "tier";
+                reward: {
+                    id: string;
+                    title: string;
+                    tiers: {
+                        id: string;
+                        title: string;
+                    }[];
+                    inventory: {
+                        kind: "untracked";
+                    };
+                    fulfillment: {
+                        kind: "staff-handover";
+                    } | {
+                        kind: "automatic";
+                    };
+                };
+                tier: string;
+            } | {
+                kind: "points";
+                balance: string;
+                amount: number;
+            })[];
+        }[];
+    } | undefined;
+    group?: string | undefined;
+} & ResourceHandle<"leaderboard">;
+/** An X post's body as content quests read it in `ctx.tracker.content.body`. */
+type XContentBody = z.infer<typeof xContentBodySchema>;
+declare const x: {
+    provider: "x";
+    /**
+     * Posts matching an X search. Each record's `data` is the provider's post payload. Its content
+     * is the post's normalized body (`XContentBody`), measured by the six X counters, so `content()`
+     * quests can use it.
+     */
+    search: (input: {
+        query: string;
+    }) => z.output<typeof xSearchSourceSchema> & WithRecordData<XTweet> & WithContent<XContentBody, XContentMetric>;
+};
+/**
+ * Records your own code sends with `trackers.ingest`. `data` is a zod object schema that every
+ * record's `data` must match: Relay stores its JSON Schema form with the tracker and rejects
+ * records that do not match it, and quests read each record's data with its type. With
+ * `identities`, each record's author, and each named account in `accounts`, is a verified identity
+ * of one of those kinds, which Relay attributes to the member who verified it, so quests can
+ * trigger from the tracker. A record states each account's `kind` unless the source names exactly
+ * one.
+ */
+/** What a content source's records carry in `data`: the body, and the metrics each sample measures. */
+type ContentData<B, M extends string> = {
+    body: B;
+    metrics?: Partial<Record<M, number>>;
+};
+/**
+ * Content your own code collects, such as posts from another platform: each record's `data` is
+ * `{ body, metrics? }`, where `body` matches the `body` schema and `metrics` holds the declared
+ * counters a sample measured (a counter a sample leaves out is unknown, never zero). The record's
+ * `author` is the creator, `occurredAt` the publication time, and its ID the content item. Quests
+ * use the tracker with `content()`, and a performance stage or engagement reward reads the
+ * declared metrics.
+ */
+declare function customSource<B extends z.ZodObject, const M extends readonly string[] = [], const A extends readonly string[] = []>(namespace: string, options: {
+    identities?: IdentityKind[];
+    accounts?: A;
+    content: {
+        body: B;
+        metrics?: M;
+    };
+}): z.output<typeof customSourceSchema> & WithRecordData<ContentData<z.input<B>, M[number]>> & WithContent<z.input<B>, M[number]> & WithAccountRoles<"author" | A[number]>;
+declare function customSource<S extends z.ZodObject, const A extends readonly string[] = []>(namespace: string, options: {
+    identities?: IdentityKind[];
+    accounts?: A;
+    data: S;
+}): z.output<typeof customSourceSchema> & WithRecordData<z.input<S>> & WithAccountRoles<"author" | A[number]>;
+/** The content marker of a source, carried by the tracker built from it. */
+type ContentOf<S> = S extends WithContent<infer B, infer M> ? WithContent<B, M> : unknown;
+declare function defineTracker<S extends TrackerSource>(input: Omit<z.input<typeof trackerDefinitionSchema>, "source"> & {
+    source: S;
+}): Tracker<TrackerData<S>> & ContentOf<S> & WithAccountRoles<SourceRoles<S>>;
+type ChannelTypes = Extract<ResourceSource, {
+    resource: "channel";
+}>["types"];
+type DiscordMessagesSource = z.output<typeof discordMessagesSourceSchema>;
+/**
+ * Messages members post in the project's Discord server. The Discord gateway writes one record per
+ * message, keyed by the message ID: its `author` is the poster's Discord account, `occurredAt` is
+ * when the message arrived, and `data` holds the channel, the replied-to message and the post time.
+ * A record is stored only when its author has linked that Discord account in the project, and its
+ * text only with `text: true`. Edits update stored text. Deleting a message, or publishing this
+ * tracker without `text: true`, removes retained text.
+ */
+declare function messages(options?: {
+    text?: false;
+}): DiscordMessagesSource & WithRecordData<DiscordMessageData>;
+declare function messages(options: {
+    text: true;
+}): DiscordMessagesSource & WithRecordData<DiscordMessageTextData>;
+/**
+ * Reactions members add in the project's Discord server. The Discord gateway writes one record per
+ * reaction, keyed by message, reactor and emoji: its `author` is the reactor's Discord account and
+ * its `messageAuthor` account the message's author, when Discord names it. `occurredAt` is when
+ * the reaction arrived. A record is stored only when the reactor or the message author has linked
+ * that Discord account in the project. Pay the message author with
+ * `automatic({ tracker, beneficiary: "messageAuthor" })`; reactions to one's own message are
+ * skipped.
+ */
+declare function reactions(): z.output<typeof discordReactionsSourceSchema> & WithRecordData<DiscordReactionData>;
+declare const discord: {
+    provider: "discord";
+    grantRole: (roleId: string) => {
+        kind: "integration";
+        provider: "discord";
+        action: "grant-role";
+        roleId: string;
+    };
+    messages: typeof messages;
+    reactions: typeof reactions;
+    roles(options?: {
+        assignable?: boolean;
+    }): ResourceSource;
+    channels(options?: {
+        types?: ChannelTypes;
+    }): ResourceSource;
+};
+declare const pointLedgers: () => ResourceSource;
+type Label = {
+    label: string;
+    description?: string;
+};
+declare const settings: {
+    pointLedger(options: Label & {
+        default?: LedgerHandle;
+    }): Setting<"point-ledger", z.ZodPrefault<z.core.$ZodBranded<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>, "ledger-reference", "out">>>;
+    datetime(options: Label & {
+        default: string;
+    }): Setting<"datetime", z.ZodDefault<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<string, string>>>>;
+    resource(options: Label & {
+        source: ResourceSource;
+        default?: string;
+    }): Setting<"resource", z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
+    quiz(options: Label & {
+        default: QuizContent;
+    }): Setting<"quiz", z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        choices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        correct: z.ZodString;
+    }, z.core.$strict>>>>;
+    text(options: Label & {
+        default: string;
+        minLength?: number;
+        maxLength?: number;
+        multiline?: boolean;
+    }): Setting<"text", z.ZodDefault<z.ZodString>>;
+    integer(options: Label & {
+        default: number;
+        min: number;
+        max: number;
+    }): Setting<"integer", z.ZodDefault<z.ZodNumber>>;
+    boolean(options: Label & {
+        default: boolean;
+    }): Setting<"boolean", z.ZodDefault<z.ZodBoolean>>;
+    choice<const T extends readonly [string, ...string[]]>(options: Label & {
+        options: T;
+        default: T[number];
+    }): Setting<"choice", z.ZodDefault<z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>>;
+    /** A quest's settings: every field is built with one of the builders above. */
+    object<T extends Record<string, Setting>>(shape: T): z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strict>;
+};
 
 type Reward = z.infer<typeof rewardSchema>;
-declare const points: (balance: string, amount: number) => {
+declare const points: (ledger: LedgerReference, amount: number) => {
     kind: "points";
     balance: string;
     amount: number;
 };
-declare const discordRole: (roleId: string) => {
-    kind: "integration";
-    provider: "discord";
-    action: "grant-role";
-    roleId: string;
-};
 
 declare const evidence: {
     text: (options?: TextOptions) => {
@@ -58,81 +512,209 @@ declare function manual(options: {
     input: "none";
     actor: "staff";
 };
+/**
+ * Which members' activity a tracker trigger counts, and from when. With `enrollment: "required"`,
+ * a member's activity counts only once they enroll (`relay.quests.enroll`, or
+ * `management.quests.enroll` from a server), and `since` can also be `"enrollment"`.
+ */
+type TriggerAdmission = {
+    /** `"none"` (the default): every member who has joined the project. */
+    enrollment?: "none";
+    /**
+     * The earliest activity counted: `"activation"` (the default), records since the quest was
+     * published; `"window"`, every record in the tracker's window.
+     */
+    since?: "activation" | "window";
+} | {
+    /** Members enroll in the quest before their activity counts. */
+    enrollment: "required";
+    /**
+     * The earliest activity counted: `"activation"` (the default), `"window"`, or
+     * `"enrollment"`, records since the member enrolled. With `"activation"` or `"window"`, a
+     * record from before the member enrolled is historical.
+     */
+    since?: "activation" | "window" | "enrollment";
+};
 /** A tracker trigger: which observations of which tracker run the quest, and for whom. */
-type TrackerTriggerInput = {
-    tracker: TrackerDefinition;
+type TrackerTriggerInput<T extends Tracker = Tracker, W extends Where<TrackerData<T>> | undefined = Where<TrackerData<T>> | undefined> = TriggerAdmission & {
+    /** The tracker handle `defineTracker` returns. */
+    tracker: T;
     /**
      * Which observations fire. `"new-record"`: each record's first observation (the default for X
-     * trackers, where it means each newly collected post). `"new-observation"`: each observation
-     * that becomes its record's current one (the default for custom trackers). `"data-changed"`: a
+     * and Discord trackers, where it means each newly collected post, message or reaction).
+     * `"new-observation"`: each observation that becomes its record's current one (the default for
+     * custom trackers). `"data-changed"`: a
      * new record, or a current observation whose `data` differs from the previous one.
      */
     on?: TrackerTriggerMode;
     /**
      * Admit only observations whose `data` matches, such as `{ path: "amount", gte: 1000 }` or
-     * `{ path: "amount", gte: { setting: "threshold" } }`. Others record no outcome.
+     * `{ path: "amount", gte: { setting: "threshold" } }`, or a list of at most 10 such conditions
+     * that must all hold. Paths and values are checked against the tracker's data type, and a
+     * `setting` must name one of the quest's integer settings. Others record no outcome.
      */
-    where?: TrackerWhere;
+    where?: W;
     /**
      * The record account whose member the quest pays: `"author"` (the default), `"inReplyTo"` on
-     * an X tracker, or a named account a custom source declares in `accounts`. Skipped when that
-     * account is the record's author account or belongs to the author's member.
+     * an X tracker, `"messageAuthor"` on a Discord reactions tracker, or a named account a custom
+     * source declares in `accounts`. Skipped when that account is the record's author account or
+     * belongs to the author's member, such as a reaction to one's own message.
+     */
+    beneficiary?: RoleOf<T>;
+    /**
+     * Who releases historical activity: a record that occurred before the member linked the
+     * account it pays (an unknown link time counts as before), or before they enrolled. `"staff"`
+     * (the default): only a reviewer's retry. `"claim"`: also the member, with
+     * `relay.quests.claim`. `"automatic"`: Relay admits it, including when the member links the
+     * account or enrolls later. Accounts of kind `member` are never historical.
      */
-    beneficiary?: string;
+    historical?: "staff" | "claim" | "automatic";
 };
+/** Type-only markers a tracker trigger carries into `defineQuest`. They never exist at runtime. */
+declare const triggerData: unique symbol;
+declare const triggerSettings: unique symbol;
+declare const triggerBody: unique symbol;
+declare const triggerMetrics: unique symbol;
 /**
- * An automatic quest. With no argument it runs once its prerequisites are complete; with an
- * observation it runs for each matching observation; with a tracker it runs for each observation
- * its firing mode and filter admit, for the member Relay attributes the beneficiary account to.
+ * A tracker trigger whose records carry `data` of type `D` and whose filter compares with the
+ * settings `S`. On a content source, its content body has type `B` and its metrics are `M`.
+ * `defineQuest` types `ctx.tracker` from `D` and `B` and checks `S` against its integer settings.
  */
-declare function automatic(): {
+type TrackerTrigger<D = unknown, S extends string = never, B = never, M extends string = never> = {
     kind: "automatic";
+    tracker: TrackerTriggerPolicy;
+    readonly [triggerData]?: D;
+    readonly [triggerSettings]?: S;
+    readonly [triggerBody]?: B;
+    readonly [triggerMetrics]?: M;
 };
-declare function automatic(observation: z.infer<typeof observationTriggerSchema>): {
-    kind: "automatic";
-    observation: z.infer<typeof observationTriggerSchema>;
+/**
+ * A content quest's trigger: a tracker trigger on a content source with the content stage. It
+ * completes once per content item, so its quest takes no `completion`.
+ */
+type ContentTrigger<D = unknown, S extends string = never, B = unknown, M extends string = string> = TrackerTrigger<D, S, B, M> & {
+    tracker: TrackerTriggerPolicy & {
+        content: true;
+    };
 };
-declare function automatic(input: TrackerTriggerInput): {
+type TriggerData<G> = G extends {
+    readonly [triggerData]?: infer D;
+} ? unknown extends D ? unknown : Exclude<D, undefined> : unknown;
+type TriggerSettings<G> = G extends {
+    readonly [triggerSettings]?: infer S;
+} ? unknown extends S ? never : Exclude<S, undefined> : never;
+type TriggerBody<G> = G extends {
+    readonly [triggerBody]?: infer B;
+} ? Exclude<B, undefined> : never;
+/** The metric names a content trigger's source measures. */
+type TriggerMetrics<G> = G extends {
+    readonly [triggerMetrics]?: infer M;
+} ? Exclude<M, undefined> : never;
+/** A trigger that runs a content stage. */
+type IsContent<G> = G extends {
+    tracker: {
+        content: true;
+    };
+} ? true : false;
+/** A tracker's content body type, or never when its source declares no content. */
+type BodyOf<T> = T extends WithContent<unknown, string> ? ContentBody<T> : never;
+/**
+ * An automatic quest. With no argument it runs once its prerequisites are complete; with a tracker
+ * it runs for each observation its firing mode and filter admit, for the member Relay attributes
+ * the beneficiary account to.
+ */
+declare function automatic(): {
     kind: "automatic";
-    tracker: TrackerTriggerPolicy;
 };
-declare const budget: (definition: Budget) => {
-    id: string;
-    scope: "member" | "project";
-    period: "lifetime" | "day" | "week";
-    limit: number;
-    cost: number | {
-        balance: string;
-    };
+declare function automatic<T extends Tracker, const W extends Where<TrackerData<T>> | undefined = undefined>(input: TrackerTriggerInput<T, W>): TrackerTrigger<TrackerData<T>, WhereSetting<W>, BodyOf<T>>;
+/** A content quest's trigger: which content items of which tracker it takes, and from whom. */
+type ContentTriggerInput<T extends Tracker = Tracker, W extends Where<TrackerData<T>> | undefined = Where<TrackerData<T>> | undefined> = TriggerAdmission & {
+    /** A tracker handle from `defineTracker` whose source has content. */
+    tracker: T;
+    /** Take only content items whose first observation's `data` matches. */
+    where?: W;
+    /**
+     * Who releases historical content: posts from before the creator linked the account or
+     * enrolled. `"claim"` (the default): the creator claims it with `relay.quests.claim`. `"staff"`:
+     * only a reviewer's retry. `"automatic"`: Relay takes it.
+     */
+    historical?: "staff" | "claim" | "automatic";
 };
-declare const keyed: (key: (ctx: {
+/**
+ * A content quest: each content item a tracker collects, such as an X post or a custom source's
+ * record, becomes one attempt for its author's member, decided once on its first observation and
+ * evaluated again when its body changes. Completes once per content item: the quest takes no
+ * `completion`. With `performance`, a later observation's metrics gate the rewards.
+ */
+declare function content<T extends Tracker & WithContent<unknown, string>, const W extends Where<TrackerData<T>> | undefined = undefined>(input: ContentTriggerInput<T, W>): ContentTrigger<TrackerData<T>, WhereSetting<W>, ContentBody<T>, ContentMetricName<T>>;
+/**
+ * What a trigger `G` supplies under key `K`: `Present` when the trigger has it, null when it cannot,
+ * and `Present | null` when `G` is not known.
+ */
+type Supplied<G, K extends string, Present, Base> = unknown extends G ? Base | null : G extends unknown ? K extends keyof G ? [G[K]] extends [object] ? Present : Base | null : null : never;
+/**
+ * `ctx.tracker` for a trigger: non-null and typed for a tracker trigger, null for others. On a
+ * content source, `content.body` has the source's body type.
+ */
+type ContextTracker<G> = Supplied<G, "tracker", TrackerTriggerContext<TriggerData<G>, TriggerBody<G>>, TrackerTriggerContext>;
+/**
+ * What a `keyed()` completion key reads. TypeScript cannot carry the trigger into a completion
+ * built inline, so `tracker` stays nullable here; the evaluator's `ctx.tracker` is typed.
+ */
+type KeyedContext = {
     member: {
         id: string;
     };
-    content?: AdmittedContent | null;
-    observation: Observation | null;
-    /** The pinned tracker observation of a tracker-triggered quest. */
-    tracker?: TrackerTriggerContext | null;
+    /** The pinned tracker observation of a tracker-triggered quest; null for other triggers. */
+    tracker: TrackerTriggerContext | null;
     eligibleAt: number;
+    /** The evaluation run's pinned project calendar. */
+    calendar: EvaluationCalendar;
     /** The attempt's evaluation time; see {@link EvaluationContext.now}. */
     now: number;
-}) => string) => {
+};
+declare const budget: (definition: Omit<Budget, "id" | "cost"> & {
+    key: string;
+    cost: number | {
+        ledger: LedgerReference;
+    };
+}) => {
+    id: string;
+    scope: "member" | "project";
+    period: "lifetime" | "day" | "week" | "month";
+    limit: number;
+    cost: number | {
+        balance: string;
+    };
+};
+declare const keyed: (key: (ctx: KeyedContext) => string) => {
     kind: "keyed";
-    key: (ctx: {
-        member: {
-            id: string;
-        };
-        content?: AdmittedContent | null;
-        observation: Observation | null;
-        /** The pinned tracker observation of a tracker-triggered quest. */
-        tracker?: TrackerTriggerContext | null;
-        eligibleAt: number;
-        /** The attempt's evaluation time; see {@link EvaluationContext.now}. */
-        now: number;
-    }) => string;
+    key: (ctx: KeyedContext) => string;
 };
-declare const completed: (quest: AuthoringIdentity | string) => {
-    quest: string;
+/** Accepted evidence contributes once under its distinct key; Relay commits progress with rewards. */
+declare const progress: (definition: {
+    distinct: (ctx: KeyedContext) => string;
+    goal: ReturnType<typeof count>;
+    window?: ReturnType<typeof calendar>;
+    repeat?: "once" | "repeat";
+}) => {
+    distinct: (ctx: KeyedContext) => string;
+    kind: "progress";
+    goal: {
+        kind: "count";
+        count: number;
+    };
+    window: {
+        kind: "lifetime";
+    } | {
+        kind: "calendar";
+        period: "day" | "week" | "month";
+        latenessMs: number;
+    } | {
+        kind: "rolling";
+        durationMs: number;
+    };
+    repeat: "repeat" | "once";
 };
 declare const untracked: () => {
     kind: "untracked";
@@ -140,11 +722,17 @@ declare const untracked: () => {
 declare const staffHandover: () => {
     kind: "staff-handover";
 };
-declare function defineTieredReward(input: Omit<TieredRewardDefinition, "id"> & AuthoringIdentity): {
+declare const automaticFulfillment: () => {
+    kind: "automatic";
+};
+declare function defineTieredReward<const T extends readonly {
     key: string;
-    /** @deprecated Authoring key alias. Use key. */
-    id: string;
-    tier: (tier: string) => {
+    title: string;
+}[]>(input: Omit<TieredRewardDefinition, "id" | "tiers"> & AuthoringIdentity & {
+    tiers: T;
+}): {
+    key: string;
+    tier: (tier: T[number]["key"]) => {
         kind: "tier";
         reward: {
             id: string;
@@ -158,25 +746,23 @@ declare function defineTieredReward(input: Omit<TieredRewardDefinition, "id"> &
             };
             fulfillment: {
                 kind: "staff-handover";
+            } | {
+                kind: "automatic";
             };
         };
         tier: string;
     };
-};
+} & ResourceHandle<"tiered-reward">;
 declare const once: () => {
     kind: "once";
 };
-type Outcome = {
+type Outcome = (Omit<Extract<Decision, {
     kind: "accept";
+}>, "rewards"> & {
     rewards?: Reward[];
-} | {
-    kind: "review";
-    reason: string;
-    rewards?: Reward[];
-} | {
-    kind: "reject";
-    reason: string;
-};
+}) | Exclude<Decision, {
+    kind: "accept";
+}>;
 /**
  * A performance evaluator's answer. It gates the rewards content evaluation already selected, so
  * it carries none: a `rewards` value fails the evaluation.
@@ -195,9 +781,11 @@ type PerformanceOutcome = {
 declare function accept(): {
     kind: "accept";
 };
-declare function accept(options: {
-    rewards?: Reward[];
-}): Outcome;
+declare function accept(options: Omit<Extract<Outcome, {
+    kind: "accept";
+}>, "kind">): Extract<Outcome, {
+    kind: "accept";
+}>;
 declare function review(options: {
     reason: string;
     rewards?: undefined;
@@ -205,12 +793,23 @@ declare function review(options: {
     kind: "review";
     reason: string;
 };
-declare function review(options: {
-    reason: string;
-    rewards?: Reward[];
-}): Outcome;
+declare function review(options: Omit<Extract<Outcome, {
+    kind: "review";
+}>, "kind">): Extract<Outcome, {
+    kind: "review";
+}>;
 declare const decision: {
     accept: typeof accept;
+    defer: (options: Omit<Extract<Decision, {
+        kind: "defer";
+    }>, "kind">) => Extract<Decision, {
+        kind: "defer";
+    }>;
+    progress: (options: Omit<Extract<Decision, {
+        kind: "progress";
+    }>, "kind">) => Extract<Decision, {
+        kind: "progress";
+    }>;
     reject: (options: {
         reason: string;
     }) => {
@@ -219,35 +818,70 @@ declare const decision: {
     };
     review: typeof review;
 };
+/** The member an attempt evaluates. */
+type EvaluationMember = {
+    id: string;
+    /**
+     * The member's selected X and Discord accounts and their `app:<name>` identities in this
+     * project, pinned once per evaluation run at the first call: later links and unlinks do not change
+     * this evaluation. Null when the member has none. `ctx.wallet.list()` reads wallets.
+     */
+    identities(): Promise<MemberIdentity[] | null>;
+};
+/** One project-calendar day, with epoch-millisecond bounds. */
+type EvaluationCalendarDay = {
+    /** The stable completion-key form, such as `2026-10-01@Europe/Budapest`. */
+    key: string;
+    /** The local ISO date in `timeZone`. */
+    date: string;
+    timeZone: string;
+    /** Inclusive epoch-millisecond boundary. */
+    start: number;
+    /** Exclusive epoch-millisecond boundary. */
+    end: number;
+};
+/** The project calendar pinned for one evaluation run. */
+type EvaluationCalendar = {
+    /** The day containing `at`, or the activity's `eligibleAt` when omitted. */
+    day(at?: number): EvaluationCalendarDay;
+};
+/**
+ * What an evaluator reads. `G` is the quest's trigger: `tracker` and `content` are non-null for
+ * the trigger that supplies them and null otherwise. `G` defaults to `any`, which
+ * leaves them nullable and lets a shared evaluator, such as `evaluators.photo()`, fit every quest.
+ */
+type IntegrationReaders<D extends readonly IntegrationModule[]> = Pick<{
+    x: XReader;
+    discord: DiscordReader;
+}, D[number]["provider"]>;
 type EvaluationContext<T, I = {
     photo: string;
-}> = {
+}, G = any, D extends readonly IntegrationModule[] = readonly IntegrationModule[]> = {
     settings: T;
-    member: {
-        id: string;
-    };
+    member: EvaluationMember;
     input: I;
-    content: AdmittedContent | null;
-    observation: Observation | null;
     /**
      * The tracker observation that admitted this attempt, and the member and verified account it
-     * was attributed to. Null unless the quest has a tracker trigger.
+     * was attributed to. Present for a tracker trigger, with `record.data` of the tracker's type.
+     * On a content source, `content` holds the body revision being evaluated, with the source's
+     * body type.
      */
-    tracker: TrackerTriggerContext | null;
+    tracker: ContextTracker<G>;
     /**
-     * When the activity happened, in epoch milliseconds: the observation's or tracker record's
-     * occurrence time, else when the attempt was admitted. Budgets and daily keys use it.
+     * When the activity happened, in epoch milliseconds: the tracker record's occurrence time, else
+     * when the attempt was admitted. Budgets and daily keys use it.
      */
     eligibleAt: number;
+    /** The project calendar pinned when this evaluation run started. */
+    calendar: EvaluationCalendar;
     /**
-     * The attempt's evaluation time, in epoch milliseconds: when its first evaluation started.
-     * Every retry and replay of the attempt receives the same value, and the sandbox freezes
+     * The current evaluation run's start time in epoch milliseconds.
+     * Retries and replays of that run receive the same value; a scheduled defer starts a fresh run, and the sandbox freezes
      * `Date.now()` and `new Date()` at it. Use `eligibleAt` for when the activity
      * happened.
      */
     now: number;
     trackers: TrackerReader;
-    x: XReader;
     images: ImageReader;
     review: {
         text(options: TextReviewInput): Promise<TextResult>;
@@ -256,31 +890,11 @@ type EvaluationContext<T, I = {
             criteria: string;
         }): Promise<PhotoResult>;
     };
-    discord: {
-        member(): Promise<DiscordMember | null>;
-        message(input: {
-            channelId: string;
-            messageId: string;
-        }): Promise<DiscordMessage | null>;
-    };
-    wallet: {
-        /** The member's newest linked Solana wallet. */
-        connection(): Promise<WalletConnection | null>;
-        /** SOL held by the newest linked Solana wallet. */
-        solanaBalance(): Promise<SolanaBalance | null>;
-        /** Every wallet the member has linked to this project, pinned once per attempt. */
-        list(): Promise<LinkedWallet[]>;
-        /**
-         * The native or token balance of the member's pinned linked wallets on one chain: all wallets of
-         * that family, or `address` (which must be one of them). No wallets gives `total: "0"` and
-         * `wallets: []`. Provider failures throw; they never read as a zero balance.
-         */
-        balance(query: WalletBalanceQuery): Promise<WalletBalance>;
-    };
-};
+    wallet: WalletReader;
+} & IntegrationReaders<D>;
 type Evaluator<T, I = {
     photo: string;
-}> = (ctx: EvaluationContext<T, I>) => Promise<Outcome>;
+}, G = any, D extends readonly IntegrationModule[] = readonly []> = (ctx: EvaluationContext<T, I, G, D>) => Promise<Outcome>;
 declare const evaluators: {
     quiz(answerKey: QuizEvidence["answers"], options?: {
         minimumCorrect?: number;
@@ -304,21 +918,59 @@ type QuestInput<T extends Trigger> = T extends {
 } ? TextEvidence : T extends {
     input: "url";
 } ? UrlEvidence : Record<string, never>;
-declare function defineQuest<T extends Record<string, z.ZodType>, const G extends Trigger, const M extends readonly [ContentMetric, ...ContentMetric[]] = readonly [
-    ContentMetric,
-    ...ContentMetric[]
-]>(definition: AuthoringIdentity & {
+/**
+ * Rejects a trigger whose filter compares with settings that are not integer settings of the
+ * quest, naming them.
+ */
+type IntegerSettingBounds<G, T> = [
+    Exclude<TriggerSettings<G>, IntegerSettings<T>>
+] extends [never] ? unknown : {
+    readonly "The tracker filter compares with settings that are not integer settings of this quest": Exclude<TriggerSettings<G>, IntegerSettings<T>>;
+};
+/** How a quest completes: a content quest once per content item, so it takes no `completion`. */
+type CompletionFor<G> = IsContent<G> extends true ? {
+    /** A content quest completes once per content item; it takes no completion. */
+    completion?: never;
+} : G extends {
+    kind: "automatic";
+    tracker?: never;
+} ? {
+    completion: ReturnType<typeof once>;
+} : {
+    completion: ReturnType<typeof once> | ReturnType<typeof keyed> | StreakPolicy | ReturnType<typeof progress>;
+};
+/** What a content quest's performance stage reads: the declared metrics it chose, fresh. */
+type PerformanceContext<S, G, M extends string> = {
+    settings: S;
+    member: {
+        id: string;
+    };
+    /** The content item's pinned observation, attribution and body revision. */
+    tracker: ContextTracker<G>;
+    /** The chosen metrics of one complete, fresh sample. */
+    metrics: Record<M, number>;
+    /** When the sample was observed. */
+    observedAt: number;
+};
+/** A concrete quest: prerequisite-only automatic triggers need at least one prerequisite. */
+declare const defineQuest: <T extends Record<string, Setting>, const G extends Trigger, const D extends readonly IntegrationModule[] = readonly [], const M extends readonly [string, ...string[]] = readonly [string, ...string[]]>(definition: AuthoringIdentity & CompletionFor<G> & (G extends {
+    kind: "automatic";
+    tracker?: never;
+} ? {
+    requires: readonly [Prerequisite, ...Prerequisite[]];
+} : unknown) & {
     title: string | ((ctx: {
-        settings: z.output<z.ZodObject<T>>;
+        settings: z.core.$InferObjectOutput<T, {}>;
     }) => string);
-    settings: z.ZodObject<T>;
-    presentation?: (ctx: {
-        settings: z.output<z.ZodObject<T>>;
-    }) => QuestPresentation;
-    trigger: G;
-    integrations?: IntegrationProvider[];
-    requires?: ReturnType<typeof completed>[];
-    completion: ReturnType<typeof once> | ReturnType<typeof keyed> | StreakPolicy;
+    settings: z.ZodObject<T, z.core.$strip>;
+    presentation?: ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => QuestPresentation) | undefined;
+    trigger: G & NoInfer<IntegerSettingBounds<G, T>>;
+    integrations?: D | undefined;
+    requires?: readonly Prerequisite[];
+    campaign?: CampaignDefinition;
+    availability?: AvailabilityWindow;
     visibility?: "visible" | "hidden";
     /**
      * `{ visible: true }` lists the quest's completions on participant profiles
@@ -326,37 +978,65 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
      */
     profile?: QuestProfile;
     budgets?: Budget[];
-    review?: (ctx: {
-        settings: z.output<z.ZodObject<T>>;
+    /**
+     * Whether staff can review this quest's attempts. Human review is on unless this returns
+     * `{ enabled: false }`. With it off, `decision.review(...)` becomes a reject that keeps the
+     * review reason, and the attempt records `requestedReview: true`; Console shows "Would have
+     * gone to review; human review is off".
+     */
+    review?: ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
     }) => {
         enabled: boolean;
-    };
-    rewards: Reward[] | ((ctx: {
-        settings: z.output<z.ZodObject<T>>;
-    }) => Reward[]);
-    evaluate?: Evaluator<z.output<z.ZodObject<T>>, QuestInput<G>>;
-    performance?: G extends {
-        content: unknown;
-    } ? {
-        metrics: M;
-        maxAgeMs?: number;
-        evaluate: (ctx: {
-            settings: z.output<z.ZodObject<T>>;
-            member: {
+    }) | undefined;
+    rewards: ({
+        kind: "tier";
+        reward: {
+            id: string;
+            title: string;
+            tiers: {
                 id: string;
-            };
-            content: AdmittedContent;
-            metrics: Record<M[number], number>;
-            observedAt: number;
-        }) => PerformanceOutcome | Promise<PerformanceOutcome>;
-    } : never;
-}): {
+                title: string;
+            }[];
+            inventory: {
+                kind: "untracked";
+            };
+            fulfillment: {
+                kind: "staff-handover";
+            } | {
+                kind: "automatic";
+            };
+        };
+        tier: string;
+    } | {
+        kind: "integration";
+        provider: "discord";
+        action: "grant-role";
+        roleId: string;
+    } | {
+        kind: "points";
+        balance: string;
+        amount: number;
+    })[] | ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => Reward[]);
+    evaluate?: Evaluator<z.core.$InferObjectOutput<T, {}>, QuestInput<G>, NoInfer<G>, NoInfer<D>> | undefined;
+    /**
+     * A content quest's performance stage: once content evaluation accepts an item, each later
+     * complete and fresh sample of `metrics` (a subset of the tracker's declared metrics) gates the
+     * rewards it selected.
+     */
+    performance?: (IsContent<G> extends true ? {
+        metrics: M & readonly TriggerMetrics<G>[];
+        maxAgeMs?: number;
+        evaluate: (ctx: PerformanceContext<z.core.$InferObjectOutput<T, {}>, G, M[number]>) => PerformanceOutcome | Promise<PerformanceOutcome>;
+    } : never) | undefined;
+}) => {
+    protocol: number;
     key: string;
-    /** @deprecated Authoring key alias. Use key. */
-    id: string;
     describe: (input: unknown) => {
         quest: string;
-        runtimeVersion: 1 | 2;
+        evaluatorProtocol: 2;
         title: string;
         presentation: {
             quiz?: {
@@ -378,7 +1058,7 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                 } | undefined;
             } | undefined;
         };
-        integrations: "discord"[];
+        integrations: ("discord" | "x")[];
         fields: Record<string, {
             kind: "point-ledger";
             default: string;
@@ -393,9 +1073,6 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
             kind: "resource";
             default: string;
             source: {
-                provider: "domino";
-                resource: "point-ledger";
-            } | {
                 provider: "discord";
                 resource: "channel";
                 types: ("text" | "announcement")[];
@@ -403,6 +1080,9 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                 provider: "discord";
                 resource: "role";
                 assignable: boolean;
+            } | {
+                provider: "domino";
+                resource: "point-ledger";
             };
             label: string;
             description?: string | undefined;
@@ -469,41 +1149,50 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                 };
                 fulfillment: {
                     kind: "staff-handover";
+                } | {
+                    kind: "automatic";
                 };
             };
             tier: string;
-        } | {
-            kind: "points";
-            balance: string;
-            amount: number;
         } | {
             kind: "integration";
             provider: "discord";
             action: "grant-role";
             roleId: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
         })[];
         humanReview: boolean;
         trigger: {
+            kind: "manual";
+            input: "text";
+            constraints: {
+                required: boolean;
+                minLength: number;
+                maxLength: number;
+            };
+            actor?: "staff" | "member" | undefined;
+        } | {
+            kind: "manual";
+            input: "url";
+            constraints: {
+                required: boolean;
+                allowedHosts?: string[] | undefined;
+            };
+            actor?: "staff" | "member" | undefined;
+        } | {
+            kind: "manual";
+            input: "none" | "quiz" | "photo";
+            actor?: "staff" | "member" | undefined;
+        } | {
             kind: "automatic";
-            observation?: {
-                source: string;
-                type: string;
-            } | undefined;
-            content?: {
-                tracker: string;
-                window: {
-                    start: number;
-                    end?: number | undefined;
-                };
-                enrollment: "required" | "none";
-                posts: "after-enrollment" | "since-start";
-                historical: "staff" | "automatic" | "claim";
-            } | undefined;
             tracker?: {
                 tracker: string;
-                source: "custom" | "x-search";
+                source: string;
+                on: "new-record" | "new-observation" | "data-changed";
                 beneficiary: string;
-                on?: "new-record" | "new-observation" | "data-changed" | undefined;
                 where?: {
                     path: string;
                     gt?: number | {
@@ -521,9 +1210,355 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                 } | {
                     path: string;
                     equals: string | number | boolean;
+                } | ({
+                    path: string;
+                    gt?: number | {
+                        setting: string;
+                    } | undefined;
+                    gte?: number | {
+                        setting: string;
+                    } | undefined;
+                    lt?: number | {
+                        setting: string;
+                    } | undefined;
+                    lte?: number | {
+                        setting: string;
+                    } | undefined;
+                } | {
+                    path: string;
+                    equals: string | number | boolean;
+                })[] | undefined;
+                enrollment?: "none" | "required" | undefined;
+                since?: "activation" | "window" | "enrollment" | undefined;
+                historical?: "staff" | "claim" | "automatic" | undefined;
+                content?: true | undefined;
+            } | undefined;
+        };
+        requires: ({
+            kind: "completion";
+            quest: string;
+            scope: "ever";
+        } | {
+            kind: "completion";
+            quest: string;
+            scope: "period";
+            period: "day" | "week" | "month";
+        } | {
+            kind: "balance";
+            balance: string;
+            minimum: number;
+        } | {
+            kind: "group";
+            group: string;
+            title: string;
+        })[];
+        completion: {
+            kind: "progress";
+            goal: {
+                kind: "count";
+                count: number;
+            };
+            window: {
+                kind: "lifetime";
+            } | {
+                kind: "calendar";
+                period: "day" | "week" | "month";
+                latenessMs: number;
+            } | {
+                kind: "rolling";
+                durationMs: number;
+            };
+            repeat: "repeat" | "once";
+        } | {
+            kind: "streak";
+            days: number;
+        } | {
+            kind: "once";
+        } | {
+            kind: "keyed";
+        };
+        visibility: "visible" | "hidden";
+        profile: {
+            visible: boolean;
+        };
+        budgets: {
+            id: string;
+            scope: "member" | "project";
+            period: "lifetime" | "day" | "week" | "month";
+            limit: number;
+            cost: number | {
+                balance: string;
+            };
+        }[];
+        performance?: {
+            metrics: string[];
+            maxAgeMs: number;
+        } | undefined;
+        campaign?: {
+            key: string;
+            title: string;
+            enrollment: "none" | "required";
+            window?: {
+                from: number;
+                until: number;
+            } | undefined;
+        } | undefined;
+        availability?: {
+            from: number;
+            until: number;
+        } | undefined;
+    };
+    evaluate(ctx: {
+        settings: unknown;
+        member: EvaluationMember;
+        input: QuestInput<G>;
+        /**
+         * The tracker observation that admitted this attempt, and the member and verified account it
+         * was attributed to. Present for a tracker trigger, with `record.data` of the tracker's type.
+         * On a content source, `content` holds the body revision being evaluated, with the source's
+         * body type.
+         */
+        tracker: TrackerTriggerContext | null;
+        /**
+         * When the activity happened, in epoch milliseconds: the tracker record's occurrence time, else
+         * when the attempt was admitted. Budgets and daily keys use it.
+         */
+        eligibleAt: number;
+        /** The project calendar pinned when this evaluation run started. */
+        calendar: EvaluationCalendar;
+        /**
+         * The current evaluation run's start time in epoch milliseconds.
+         * Retries and replays of that run receive the same value; a scheduled defer starts a fresh run, and the sandbox freezes
+         * `Date.now()` and `new Date()` at it. Use `eligibleAt` for when the activity
+         * happened.
+         */
+        now: number;
+        trackers: TrackerReader;
+        images: ImageReader;
+        review: {
+            text(options: TextReviewInput): Promise<TextResult>;
+            photo(options: {
+                image: string;
+                criteria: string;
+            }): Promise<PhotoResult>;
+        };
+        wallet: WalletReader;
+    } & IntegrationReaders<readonly IntegrationModule[]> & {
+        rewards: Reward[];
+        humanReview: boolean;
+        performance?: unknown;
+    }): Promise<Decision>;
+} & ResourceHandle<"quest">;
+/** Publish this artifact as a reusable type. Its key names the type;
+ * Console instances receive independent quest identities and pinned versions. */
+declare const defineQuestType: <T extends Record<string, Setting>, const G extends Trigger, const D extends readonly IntegrationModule[] = readonly [], const M extends readonly [string, ...string[]] = readonly [string, ...string[]]>(definition: AuthoringIdentity & CompletionFor<G> & {
+    title: string | ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => string);
+    settings: z.ZodObject<T, z.core.$strip>;
+    presentation?: ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => QuestPresentation) | undefined;
+    trigger: G & NoInfer<IntegerSettingBounds<G, T>>;
+    integrations?: D | undefined;
+    requires?: readonly Prerequisite[];
+    campaign?: CampaignDefinition;
+    availability?: AvailabilityWindow;
+    visibility?: "visible" | "hidden";
+    /**
+     * `{ visible: true }` lists the quest's completions on participant profiles
+     * (`relay.profiles.completions`). Hidden by default.
+     */
+    profile?: QuestProfile;
+    budgets?: Budget[];
+    /**
+     * Whether staff can review this quest's attempts. Human review is on unless this returns
+     * `{ enabled: false }`. With it off, `decision.review(...)` becomes a reject that keeps the
+     * review reason, and the attempt records `requestedReview: true`; Console shows "Would have
+     * gone to review; human review is off".
+     */
+    review?: ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => {
+        enabled: boolean;
+    }) | undefined;
+    rewards: ({
+        kind: "tier";
+        reward: {
+            id: string;
+            title: string;
+            tiers: {
+                id: string;
+                title: string;
+            }[];
+            inventory: {
+                kind: "untracked";
+            };
+            fulfillment: {
+                kind: "staff-handover";
+            } | {
+                kind: "automatic";
+            };
+        };
+        tier: string;
+    } | {
+        kind: "integration";
+        provider: "discord";
+        action: "grant-role";
+        roleId: string;
+    } | {
+        kind: "points";
+        balance: string;
+        amount: number;
+    })[] | ((ctx: {
+        settings: z.core.$InferObjectOutput<T, {}>;
+    }) => Reward[]);
+    evaluate?: Evaluator<z.core.$InferObjectOutput<T, {}>, QuestInput<G>, NoInfer<G>, NoInfer<D>> | undefined;
+    /**
+     * A content quest's performance stage: once content evaluation accepts an item, each later
+     * complete and fresh sample of `metrics` (a subset of the tracker's declared metrics) gates the
+     * rewards it selected.
+     */
+    performance?: (IsContent<G> extends true ? {
+        metrics: M & readonly TriggerMetrics<G>[];
+        maxAgeMs?: number;
+        evaluate: (ctx: PerformanceContext<z.core.$InferObjectOutput<T, {}>, G, M[number]>) => PerformanceOutcome | Promise<PerformanceOutcome>;
+    } : never) | undefined;
+}) => {
+    protocol: number;
+    key: string;
+    describe: (input: unknown) => {
+        quest: string;
+        evaluatorProtocol: 2;
+        title: string;
+        presentation: {
+            quiz?: {
+                id: string;
+                prompt: string;
+                choices: {
+                    id: string;
+                    label: string;
+                }[];
+            }[] | undefined;
+            instructions?: string | undefined;
+            video?: {
+                url: string;
+                poster?: string | undefined;
+                captions?: {
+                    url: string;
+                    language: string;
+                    label: string;
                 } | undefined;
             } | undefined;
+        };
+        integrations: ("discord" | "x")[];
+        fields: Record<string, {
+            kind: "point-ledger";
+            default: string;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "datetime";
+            default: string;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "resource";
+            default: string;
+            source: {
+                provider: "discord";
+                resource: "channel";
+                types: ("text" | "announcement")[];
+            } | {
+                provider: "discord";
+                resource: "role";
+                assignable: boolean;
+            } | {
+                provider: "domino";
+                resource: "point-ledger";
+            };
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "quiz";
+            default: {
+                id: string;
+                prompt: string;
+                choices: {
+                    id: string;
+                    label: string;
+                }[];
+                correct: string;
+            }[];
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "text";
+            default: string;
+            minLength: number;
+            maxLength: number;
+            multiline: boolean;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "integer";
+            default: number;
+            min: number;
+            max: number;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "boolean";
+            default: boolean;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "choice";
+            default: string;
+            options: string[];
+            label: string;
+            description?: string | undefined;
+        }>;
+        values: Record<string, string | number | boolean | {
+            id: string;
+            prompt: string;
+            choices: {
+                id: string;
+                label: string;
+            }[];
+            correct: string;
+        }[]>;
+        rewards: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                } | {
+                    kind: "automatic";
+                };
+            };
+            tier: string;
         } | {
+            kind: "integration";
+            provider: "discord";
+            action: "grant-role";
+            roleId: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+        humanReview: boolean;
+        trigger: {
             kind: "manual";
             input: "text";
             constraints: {
@@ -542,47 +1577,170 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
             actor?: "staff" | "member" | undefined;
         } | {
             kind: "manual";
-            input: "photo" | "quiz" | "none";
+            input: "none" | "quiz" | "photo";
             actor?: "staff" | "member" | undefined;
+        } | {
+            kind: "automatic";
+            tracker?: {
+                tracker: string;
+                source: string;
+                on: "new-record" | "new-observation" | "data-changed";
+                beneficiary: string;
+                where?: {
+                    path: string;
+                    gt?: number | {
+                        setting: string;
+                    } | undefined;
+                    gte?: number | {
+                        setting: string;
+                    } | undefined;
+                    lt?: number | {
+                        setting: string;
+                    } | undefined;
+                    lte?: number | {
+                        setting: string;
+                    } | undefined;
+                } | {
+                    path: string;
+                    equals: string | number | boolean;
+                } | ({
+                    path: string;
+                    gt?: number | {
+                        setting: string;
+                    } | undefined;
+                    gte?: number | {
+                        setting: string;
+                    } | undefined;
+                    lt?: number | {
+                        setting: string;
+                    } | undefined;
+                    lte?: number | {
+                        setting: string;
+                    } | undefined;
+                } | {
+                    path: string;
+                    equals: string | number | boolean;
+                })[] | undefined;
+                enrollment?: "none" | "required" | undefined;
+                since?: "activation" | "window" | "enrollment" | undefined;
+                historical?: "staff" | "claim" | "automatic" | undefined;
+                content?: true | undefined;
+            } | undefined;
         };
-        requires: {
+        requires: ({
+            kind: "completion";
             quest: string;
-        }[];
+            scope: "ever";
+        } | {
+            kind: "completion";
+            quest: string;
+            scope: "period";
+            period: "day" | "week" | "month";
+        } | {
+            kind: "balance";
+            balance: string;
+            minimum: number;
+        } | {
+            kind: "group";
+            group: string;
+            title: string;
+        })[];
         completion: {
+            kind: "progress";
+            goal: {
+                kind: "count";
+                count: number;
+            };
+            window: {
+                kind: "lifetime";
+            } | {
+                kind: "calendar";
+                period: "day" | "week" | "month";
+                latenessMs: number;
+            } | {
+                kind: "rolling";
+                durationMs: number;
+            };
+            repeat: "repeat" | "once";
+        } | {
             kind: "streak";
             days: number;
-            timeZone: string;
         } | {
             kind: "once";
         } | {
             kind: "keyed";
         };
         visibility: "visible" | "hidden";
+        profile: {
+            visible: boolean;
+        };
         budgets: {
             id: string;
             scope: "member" | "project";
-            period: "lifetime" | "day" | "week";
+            period: "lifetime" | "day" | "week" | "month";
             limit: number;
             cost: number | {
                 balance: string;
             };
         }[];
         performance?: {
-            metrics: ("likes" | "replies" | "reposts" | "quotes" | "views" | "bookmarks")[];
+            metrics: string[];
             maxAgeMs: number;
         } | undefined;
-        profile?: {
-            visible: boolean;
+        campaign?: {
+            key: string;
+            title: string;
+            enrollment: "none" | "required";
+            window?: {
+                from: number;
+                until: number;
+            } | undefined;
+        } | undefined;
+        availability?: {
+            from: number;
+            until: number;
         } | undefined;
     };
-    evaluate(ctx: EvaluationContext<unknown, QuestInput<G>> & {
+    evaluate(ctx: {
+        settings: unknown;
+        member: EvaluationMember;
+        input: QuestInput<G>;
+        /**
+         * The tracker observation that admitted this attempt, and the member and verified account it
+         * was attributed to. Present for a tracker trigger, with `record.data` of the tracker's type.
+         * On a content source, `content` holds the body revision being evaluated, with the source's
+         * body type.
+         */
+        tracker: TrackerTriggerContext | null;
+        /**
+         * When the activity happened, in epoch milliseconds: the tracker record's occurrence time, else
+         * when the attempt was admitted. Budgets and daily keys use it.
+         */
+        eligibleAt: number;
+        /** The project calendar pinned when this evaluation run started. */
+        calendar: EvaluationCalendar;
+        /**
+         * The current evaluation run's start time in epoch milliseconds.
+         * Retries and replays of that run receive the same value; a scheduled defer starts a fresh run, and the sandbox freezes
+         * `Date.now()` and `new Date()` at it. Use `eligibleAt` for when the activity
+         * happened.
+         */
+        now: number;
+        trackers: TrackerReader;
+        images: ImageReader;
+        review: {
+            text(options: TextReviewInput): Promise<TextResult>;
+            photo(options: {
+                image: string;
+                criteria: string;
+            }): Promise<PhotoResult>;
+        };
+        wallet: WalletReader;
+    } & IntegrationReaders<readonly IntegrationModule[]> & {
         rewards: Reward[];
         humanReview: boolean;
         performance?: unknown;
     }): Promise<Decision>;
-};
-/** Publish this artifact as a reusable type. Its key names the type;
- * Console instances receive independent quest identities and pinned versions. */
-declare const defineQuestType: typeof defineQuest;
+} & ResourceHandle<"quest">;
 
-export { type EvaluationContext, type PerformanceOutcome, TrackerTriggerContext, type TrackerTriggerInput, WalletBalance, WalletBalanceQuery, automatic, budget, completed, decision, defineQuest, defineQuestType, defineTieredReward, discordRole, evaluators, evidence, keyed, manual, once, points, staffHandover, untracked };
+export { ContentBody, type ContentData, ContentMetricName, type ContentTrigger, type ContentTriggerInput, DiscordMessageData, DiscordMessageTextData, DiscordReactionData, DiscordReader, type EvaluationCalendar, type EvaluationCalendarDay, type EvaluationContext, type EvaluationMember, GroupHandle, IdentityKind, ImageReader, IntegrationModule, type KeyedContext, LedgerHandle, LedgerReference, MemberIdentity, type Outcome, type PerformanceContext, type PerformanceOutcome, QuestHandle, RoleOf, Setting, Tracker, TrackerData, TrackerReader, type TrackerTrigger, TrackerTriggerContext, type TrackerTriggerInput, type TriggerAdmission, WalletReader, Where, type XContentBody, XReader, automatic, automaticFulfillment, budget, calendar, content, count, customSource, decision, defineEngagementReward, defineLeaderboard, defineLedger, defineQuest, defineQuestType, defineReferral, defineTieredReward, defineTracker, discord, earned, evaluators, evidence, keyed, manual, once, pointLedgers, points, progress, questCompleted, rolling, settings, staffHandover, streak, untracked, x };