@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/{integrations-B3y36OaB.d.ts → limits-kNzYdZ00.d.ts}

@@ -1,4 +1,332 @@
 import * as z from 'zod';
+import { aa as PhotoResult, V as AttemptCodeSource } from './accounts-nz3mzfRQ.js';
+
+/**
+ * Quest code names an image; the platform fetches, decodes and pins it. No bytes or URLs cross the
+ * sandbox boundary, so a quest cannot make the platform fetch an arbitrary address.
+ */
+declare const imageReferenceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    evidence: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    x: z.ZodLiteral<"profile">;
+}, z.core.$strict>, z.ZodObject<{
+    x: z.ZodLiteral<"post">;
+    postId: z.ZodString;
+    index: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    asset: z.ZodString;
+}, z.core.$strict>]>;
+type ImageReference = z.input<typeof imageReferenceSchema>;
+declare const imageFieldSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    description: z.ZodString;
+}, z.core.$strict>;
+declare const imageFieldsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    description: z.ZodString;
+}, z.core.$strict>>;
+type ImageFields = z.input<typeof imageFieldsSchema>;
+declare const imageRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"inspect">;
+    image: z.ZodUnion<readonly [z.ZodObject<{
+        evidence: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"profile">;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"post">;
+        postId: z.ZodString;
+        index: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        asset: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"compare">;
+    images: z.ZodTuple<[z.ZodUnion<readonly [z.ZodObject<{
+        evidence: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"profile">;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"post">;
+        postId: z.ZodString;
+        index: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        asset: z.ZodString;
+    }, z.core.$strict>]>, z.ZodUnion<readonly [z.ZodObject<{
+        evidence: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"profile">;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"post">;
+        postId: z.ZodString;
+        index: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        asset: z.ZodString;
+    }, z.core.$strict>]>], null>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"review">;
+    images: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        evidence: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"profile">;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"post">;
+        postId: z.ZodString;
+        index: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        asset: z.ZodString;
+    }, z.core.$strict>]>>;
+    criteria: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"extract">;
+    image: z.ZodUnion<readonly [z.ZodObject<{
+        evidence: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"profile">;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"post">;
+        postId: z.ZodString;
+        index: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        asset: z.ZodString;
+    }, z.core.$strict>]>;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"seen">;
+    image: z.ZodUnion<readonly [z.ZodObject<{
+        evidence: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"profile">;
+    }, z.core.$strict>, z.ZodObject<{
+        x: z.ZodLiteral<"post">;
+        postId: z.ZodString;
+        index: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        asset: z.ZodString;
+    }, z.core.$strict>]>;
+    maxDistance: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>], "operation">;
+type ImageRequest = z.input<typeof imageRequestSchema>;
+declare const imageInspectionSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        png: "png";
+        webp: "webp";
+        gif: "gif";
+        avif: "avif";
+    }>;
+    bytes: z.ZodNumber;
+    sha256: z.ZodString;
+    phash: z.ZodString;
+    dhash: z.ZodString;
+}, z.core.$strict>;
+type ImageInspection = z.infer<typeof imageInspectionSchema>;
+declare const imageComparisonSchema: z.ZodObject<{
+    identical: z.ZodBoolean;
+    phashDistance: z.ZodNumber;
+    dhashDistance: z.ZodNumber;
+}, z.core.$strict>;
+type ImageComparison = z.infer<typeof imageComparisonSchema>;
+declare const imageExtractionSchema: z.ZodObject<{
+    values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+type ImageExtraction = z.infer<typeof imageExtractionSchema>;
+declare const imageSightingsSchema: z.ZodObject<{
+    matches: z.ZodNumber;
+    closestDistance: z.ZodNullable<z.ZodNumber>;
+    firstSeenAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+type ImageSightings = z.infer<typeof imageSightingsSchema>;
+/**
+ * One reference image in a deployment bundle: a reference, never the bytes. The CLI uploads each
+ * file to storage before the preview; a hosted build stages it. `path` is where the bundle found
+ * the file, relative to relay.json; the platform ignores it.
+ */
+declare const imageAssetArtifactSchema: z.ZodObject<{
+    key: z.ZodString;
+    sha256: z.ZodString;
+    size: z.ZodNumber;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ImageAssetArtifact = z.infer<typeof imageAssetArtifactSchema>;
+/** Ask for upload URLs for images the project's storage does not hold yet. */
+declare const imageUploadRequestSchema: z.ZodObject<{
+    images: z.ZodArray<z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+        type: z.ZodEnum<{
+            "image/jpeg": "image/jpeg";
+            "image/png": "image/png";
+            "image/webp": "image/webp";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** `upload` is null when the image is already stored; otherwise PUT the exact bytes before it expires. */
+declare const imageUploadsSchema: z.ZodObject<{
+    images: z.ZodArray<z.ZodObject<{
+        sha256: z.ZodString;
+        upload: z.ZodNullable<z.ZodObject<{
+            url: z.ZodString;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            expiresAt: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const publishedImageSchema: z.ZodObject<{
+    key: z.ZodString;
+    sha256: z.ZodString;
+    type: z.ZodEnum<{
+        "image/jpeg": "image/jpeg";
+        "image/png": "image/png";
+        "image/webp": "image/webp";
+    }>;
+    size: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strict>;
+type PublishedImage = z.infer<typeof publishedImageSchema>;
+type Extracted<F extends ImageFields> = {
+    [K in keyof F]: (F[K]["type"] extends "number" ? number : F[K]["type"] extends "boolean" ? boolean : string) | null;
+};
+/** Evaluator `ctx.images`. Each call uses one of the evaluation's eight capability calls. */
+interface ImageReader {
+    inspect(image: ImageReference): Promise<ImageInspection>;
+    compare(a: ImageReference, b: ImageReference): Promise<ImageComparison>;
+    review(options: {
+        images: ImageReference[];
+        criteria: string;
+    }): Promise<PhotoResult>;
+    extract<const F extends ImageFields>(options: {
+        image: ImageReference;
+        fields: F;
+    }): Promise<{
+        values: Extracted<F>;
+        reason: string;
+    }>;
+    /**
+     * Records the image for this attempt, then counts other participants' recorded images within
+     * `maxDistance`. The record is written when `seen` runs, not when the attempt is decided, so it
+     * stays even if the attempt is rejected: concurrent submissions of one photo must see each
+     * other. Replays reuse the captured result.
+     */
+    seen(image: ImageReference, options?: {
+        maxDistance?: number;
+    }): Promise<ImageSightings>;
+}
+
+declare const xIdSchema: z.ZodString;
+declare const xConnectionSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+declare const xProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodString;
+    name: z.ZodString;
+    bio: z.ZodNullable<z.ZodString>;
+    profileImageUrl: z.ZodNullable<z.ZodString>;
+    followersCount: z.ZodNullable<z.ZodNumber>;
+    verified: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+/** An X handle, with or without its leading `@`: 1 to 15 letters, digits or underscores. */
+declare const xUsernameSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+declare const xUserLookupInputSchema: z.ZodObject<{
+    username: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+}, z.core.$strict>;
+type XUserLookupInput = z.input<typeof xUserLookupInputSchema>;
+/**
+ * The X account that holds a handle, as Domino last read it from X (at most a day ago). A handle
+ * can change hands, so the stable `id` is what trackers, `--author` filters and
+ * `ctx.x.follows({ userId })` take. Resolving a handle says nothing about who owns the account.
+ */
+declare const xUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+type XUser = z.infer<typeof xUserSchema>;
+declare const xPostSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    content: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    author: z.ZodObject<{
+        id: z.ZodString;
+        username: z.ZodString;
+        name: z.ZodString;
+        verified: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$loose>;
+    likeCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    replyCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    retweetCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    quoteCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    viewCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    bookmarkCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    isReply: z.ZodBoolean;
+    isRetweet: z.ZodBoolean;
+    isQuoteTweet: z.ZodBoolean;
+    quotedTweetId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    inReplyToUserId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    inReplyToStatusId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    retweetedTweetId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    media: z.ZodPipe<z.ZodOptional<z.ZodUnknown>, z.ZodTransform<{
+        type: string;
+        url: string;
+    }[], unknown>>;
+}, z.core.$loose>;
+declare const xRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"connection">;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"profile">;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"post">;
+    postId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"follows">;
+    userId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"reposted">;
+    postId: z.ZodString;
+}, z.core.$strict>], "operation">;
+type XConnection = z.infer<typeof xConnectionSchema>;
+type XProfile = z.infer<typeof xProfileSchema>;
+type XPost = z.infer<typeof xPostSchema>;
+/**
+ * Reads the member's linked X account and public X data. The account is pinned at the attempt's
+ * first X read: later links and unlinks do not change the attempt. `connection()`, `profile()`,
+ * `follows()` and `reposted()` resolve to `null` when the member has no linked X account;
+ * `post()` reads any public post and resolves to `null` when it does not exist. Provider failures
+ * throw `CapabilityError` with code `"provider-unavailable"`.
+ */
+interface XReader {
+    connection(): Promise<XConnection | null>;
+    profile(): Promise<XProfile | null>;
+    post(input: {
+        postId: string;
+    }): Promise<XPost | null>;
+    follows(input: {
+        userId: string;
+    }): Promise<boolean | null>;
+    reposted(input: {
+        postId: string;
+    }): Promise<boolean | null>;
+}
 
 /**
  * The ranges `analytics.read` covers. Each ends now: `7d`, `30d` and `90d` are that many project
@@ -34,7 +362,9 @@ declare const analyticsReadSchema: z.ZodObject<{
             all: "all";
         }>;
         from: z.ZodISODateTime;
+        fromMs: z.ZodOptional<z.ZodNumber>;
         to: z.ZodISODateTime;
+        toMs: z.ZodOptional<z.ZodNumber>;
         bucket: z.ZodEnum<{
             day: "day";
             week: "week";
@@ -43,12 +373,16 @@ declare const analyticsReadSchema: z.ZodObject<{
         buckets: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
             start: z.ZodISODateTime;
+            startMs: z.ZodOptional<z.ZodNumber>;
             end: z.ZodISODateTime;
+            endMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     previous: z.ZodOptional<z.ZodObject<{
         from: z.ZodISODateTime;
+        fromMs: z.ZodOptional<z.ZodNumber>;
         to: z.ZodISODateTime;
+        toMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     members: z.ZodObject<{
         signUps: z.ZodObject<{
@@ -95,6 +429,7 @@ declare const analyticsReadSchema: z.ZodObject<{
             topReasons: z.ZodArray<z.ZodObject<{
                 reason: z.ZodString;
                 code: z.ZodNullable<z.ZodString>;
+                codeSource: z.ZodOptional<z.ZodNullable<z.ZodType<AttemptCodeSource, unknown, z.core.$ZodTypeInternals<AttemptCodeSource, unknown>>>>;
                 count: z.ZodNumber;
             }, z.core.$strip>>;
             rejectionsBySource: z.ZodObject<{
@@ -102,6 +437,7 @@ declare const analyticsReadSchema: z.ZodObject<{
                 staff: z.ZodNumber;
                 budget: z.ZodNumber;
                 expired: z.ZodNumber;
+                keyUsed: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>;
             series: z.ZodObject<{
                 attempts: z.ZodArray<z.ZodNumber>;
@@ -169,6 +505,7 @@ declare const analyticsReadSchema: z.ZodObject<{
     }, z.core.$strip>>;
     testEnvironment: z.ZodOptional<z.ZodObject<{
         lastResetAt: z.ZodNullable<z.ZodISODateTime>;
+        lastResetAtMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         shiftedClockMembers: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -179,8 +516,9 @@ type AnalyticsMetric = AnalyticsRead["members"]["signUps"];
 type AnalyticsQuest = AnalyticsRead["quests"]["byQuest"][number];
 /**
  * How a breakdown splits a metric: by quest, offer, referral program, group, tracker or
- * leaderboard; for rejections by `source` (evaluator, staff, budget, expired) or `reason` (the
- * rejection code, else the exact text); for tracker outcomes by `outcome` (admitted or skipped).
+ * leaderboard; for rejections by `source` (evaluator, staff, budget, expired, keyUsed) or `reason`
+ * (the rejection code, with Relay's `key-used` apart from an evaluator's, else the exact text); for
+ * tracker outcomes by `outcome` (admitted or skipped).
  */
 declare const analyticsBreakdowns: readonly ["quest", "source", "reason", "offer", "program", "group", "tracker", "outcome", "leaderboard"];
 type AnalyticsBreakdown = (typeof analyticsBreakdowns)[number];
@@ -391,7 +729,11 @@ declare const analyticsCatalogSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type AnalyticsCatalog = z.infer<typeof analyticsCatalogSchema>;
-/** A breakdown or query returns up to this many rows; the rest are summed into `other`. */
+/**
+ * A breakdown or query returns up to this many rows; the rest are summed into `other`.
+ *
+ * @deprecated Use `limits.analyticsQueryRows`, which a 1.x release can raise.
+ */
 declare const analyticsQueryLimit = 100;
 /**
  * What `analytics.query` reads on the wire. The metric, breakdown and filter names are checked by
@@ -436,7 +778,9 @@ declare const analyticsMetricResultSchema: z.ZodObject<{
             all: "all";
         }>;
         from: z.ZodISODateTime;
+        fromMs: z.ZodOptional<z.ZodNumber>;
         to: z.ZodISODateTime;
+        toMs: z.ZodOptional<z.ZodNumber>;
         bucket: z.ZodEnum<{
             day: "day";
             week: "week";
@@ -445,12 +789,16 @@ declare const analyticsMetricResultSchema: z.ZodObject<{
         buckets: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
             start: z.ZodISODateTime;
+            startMs: z.ZodOptional<z.ZodNumber>;
             end: z.ZodISODateTime;
+            endMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     previous: z.ZodOptional<z.ZodObject<{
         from: z.ZodISODateTime;
+        fromMs: z.ZodOptional<z.ZodNumber>;
         to: z.ZodISODateTime;
+        toMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     ledger: z.ZodOptional<z.ZodString>;
     value: z.ZodObject<{
@@ -479,58 +827,121 @@ declare const analyticsMetricResultSchema: z.ZodObject<{
 type AnalyticsMetricResult = z.infer<typeof analyticsMetricResultSchema>;
 type AnalyticsBreakdownRow = NonNullable<AnalyticsMetricResult["breakdown"]>["rows"][number];
 
-/** Modules a quest can declare to enable provider readers. Project connections are separate. */
-declare const evaluatorIntegrationProviderSchema: z.ZodEnum<{
-    discord: "discord";
-    x: "x";
-}>;
-type EvaluatorIntegrationProvider = z.infer<typeof evaluatorIntegrationProviderSchema>;
-type IntegrationModule = {
-    readonly provider: EvaluatorIntegrationProvider;
-};
-declare const integrationProviderSchema: z.ZodEnum<{
-    discord: "discord";
-}>;
-type IntegrationProvider = z.infer<typeof integrationProviderSchema>;
-declare const discordServerSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    icon: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-declare const projectIntegrationSchema: z.ZodObject<{
-    provider: z.ZodEnum<{
-        discord: "discord";
-    }>;
-    configured: z.ZodBoolean;
-    status: z.ZodEnum<{
-        disconnected: "disconnected";
-        ready: "ready";
-        attention: "attention";
-    }>;
-    revision: z.ZodNumber;
-    server: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        icon: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
-    issue: z.ZodNullable<z.ZodString>;
-    connectedAt: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-type ProjectIntegration = z.infer<typeof projectIntegrationSchema>;
 /**
- * The Discord servers other projects of the organization connected and keep ready in the same
- * environment: the ones `management.discord.connect(server)` can connect without a new
- * installation.
+ * Relay's platform limits. A 1.x release can raise them, and add new ones. Released SDKs keep
+ * checking the values they shipped with, so Relay answers them within those.
  *
  * @compat output
  */
-declare const organizationDiscordServersSchema: z.ZodObject<{
-    servers: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        icon: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type OrganizationDiscordServers = z.infer<typeof organizationDiscordServersSchema>;
+type Limits = {
+    /** Quests one deployment, draft or release batch can hold. */
+    readonly quests: number;
+    /** Quest types one deployment, draft or release batch can hold. */
+    readonly questTypes: number;
+    /** Collections one deployment, draft or release batch can hold. */
+    readonly collections: number;
+    /** The SDK runtime a quest bundle imports instead of bundling. */
+    readonly sdkRuntime: {
+        /** Modules in one runtime. */
+        readonly modules: number;
+        /** Characters of module source, summed over all modules. */
+        readonly size: number;
+    };
+    /** The most completions one `ctx.member.completions()` call returns, and its default `limit`. */
+    readonly memberCompletions: number;
+    /** Panels one dashboard holds. */
+    readonly dashboardPanels: number;
+    /** Dashboards that are not archived one project holds. */
+    readonly dashboards: number;
+    /** Bounds for successful non-terminal evaluator decisions, independent of failure retries. */
+    readonly defer: {
+        readonly minRetryAfterMs: number;
+        readonly maxRetryAfterMs: number;
+        /** The delay a defer without `retryAfterMs` waits. */
+        readonly retryAfterMs: number;
+        /** How long after the first defer an attempt can still be deferred. */
+        readonly horizonMs: number;
+        readonly maxDefers: number;
+    };
+    /**
+     * Bounds of a quest's retry cooldown (`retryCooldownMs`) and completion cooldown
+     * (`completionCooldownMs`).
+     */
+    readonly retryCooldown: {
+        readonly minMs: number;
+        readonly maxMs: number;
+    };
+    /** Rows an analytics breakdown or query returns; the rest are summed into `other`. */
+    readonly analyticsQueryRows: number;
+    /** Limits of hosted apps, per project environment. */
+    readonly apps: {
+        /** App secrets one project environment holds. */
+        readonly secrets: number;
+        /** KV stores one app declares. */
+        readonly kvStores: number;
+        /** SQL stores one app declares. */
+        readonly sqlStores: number;
+        /** Migrations one SQL store holds. */
+        readonly migrations: number;
+        /** Bytes of one migration file. */
+        readonly migrationFileBytes: number;
+        /** Bytes of one SQL store's migrations, summed. */
+        readonly migrationTotalBytes: number;
+        /** Rows per page when browsing a SQL store's table. */
+        readonly storageRows: number;
+        /** Longest text a browsed cell or KV value shows; longer values end in `truncated`. */
+        readonly storagePreviewCharacters: number;
+        /** Characters a full SQL value read returns per page. */
+        readonly storageCellCharacters: number;
+        /** Schedules one app declares. */
+        readonly schedules: number;
+        /** The shortest interval between two runs of one schedule, in milliseconds. */
+        readonly scheduleMinIntervalMs: number;
+        /** How long Relay waits for a scheduled route to answer, in milliseconds. */
+        readonly scheduleTimeoutMs: number;
+        /**
+         * The most a scheduled route's JSON answer can hold for Relay to record it as the run's result.
+         */
+        readonly scheduleResultBytes: number;
+    };
+    /** Caps on a build's staged quest and catalog code. */
+    readonly stagedDeployment: {
+        /** Bytes of JSON, uncompressed. */
+        readonly size: number;
+        /** Bytes of the Brotli-compressed object. */
+        readonly compressedSize: number;
+    };
+    /**
+     * The most capability calls one hosted evaluation run can make, shared by all capabilities. The
+     * next call throws a `CapabilityError` with code `capability-limit`.
+     */
+    readonly capabilityCalls: number;
+    /** Bounds of a tracker data schema. */
+    readonly trackerData: {
+        /** The most branches one union may list. */
+        readonly branches: number;
+        /**
+         * The most properties, `required` keys, enum values or allowed key names one schema node lists.
+         */
+        readonly entries: number;
+    };
+    /** Bounds of an X search preview: one sample, never stored, never a tracker. */
+    readonly trackerPreview: {
+        readonly pages: number;
+        readonly posts: number;
+        readonly days: number;
+    };
+    /**
+     * The most wallets of one chain family a member can have linked to one project at a time. Sign-in
+     * wallets do not count: signing in always links the wallet.
+     */
+    readonly walletsPerChain: number;
+    /** The most logs one `ctx.wallet.events()` read may match before `where` filters them. */
+    readonly walletEventLogs: number;
+    /** The most transactions one `ctx.wallet.transactions()` read fetches per wallet. */
+    readonly walletTransactions: number;
+};
+/** Relay's platform limits. A 1.x release can raise them, so read them here at run time. */
+declare const limits: Limits;
 
-export { type AnalyticsMetricId as A, analyticsMetricQuerySchema as B, analyticsMetricResultSchema as C, analyticsQueryLimit as D, type EvaluatorIntegrationProvider as E, analyticsQuerySchema as F, analyticsRanges as G, analyticsReadSchema as H, type IntegrationModule as I, type OrganizationDiscordServers as O, type ProjectIntegration as P, analyticsCatalog as a, type IntegrationProvider as b, type AnalyticsQuery as c, discordServerSchema as d, evaluatorIntegrationProviderSchema as e, type AnalyticsRead as f, type AnalyticsCatalog as g, type AnalyticsMetricQuery as h, integrationProviderSchema as i, type AnalyticsMetricResult as j, type AnalyticsBreakdown as k, type AnalyticsBreakdownRow as l, type AnalyticsCatalogEntry as m, type AnalyticsChart as n, organizationDiscordServersSchema as o, projectIntegrationSchema as p, type AnalyticsFilter as q, type AnalyticsMetric as r, type AnalyticsMetricKind as s, type AnalyticsQuest as t, type AnalyticsRange as u, analyticsBreakdowns as v, analyticsCatalogSchema as w, analyticsCharts as x, analyticsFilters as y, analyticsMetricIds as z };
+export { type AnalyticsQuest as $, type AnalyticsMetricId as A, publishedImageSchema as B, xConnectionSchema as C, xIdSchema as D, type Extracted as E, xPostSchema as F, xProfileSchema as G, xRequestSchema as H, type ImageReader as I, xUserLookupInputSchema as J, xUserSchema as K, type Limits as L, xUsernameSchema as M, type AnalyticsQuery as N, type AnalyticsRead as O, type PublishedImage as P, type AnalyticsCatalog as Q, type AnalyticsMetricQuery as R, type AnalyticsMetricResult as S, type AnalyticsBreakdown as T, type AnalyticsBreakdownRow as U, type AnalyticsCatalogEntry as V, type AnalyticsChart as W, type XReader as X, type AnalyticsFilter as Y, type AnalyticsMetric as Z, type AnalyticsMetricKind as _, analyticsCatalog as a, type AnalyticsRange as a0, analyticsBreakdowns as a1, analyticsCatalogSchema as a2, analyticsCharts as a3, analyticsFilters as a4, analyticsMetricIds as a5, analyticsMetricQuerySchema as a6, analyticsMetricResultSchema as a7, analyticsQueryLimit as a8, analyticsQuerySchema as a9, analyticsRanges as aa, analyticsReadSchema as ab, type ImageAssetArtifact as b, type ImageComparison as c, type ImageExtraction as d, type ImageFields as e, type ImageInspection as f, type ImageReference as g, type ImageRequest as h, type ImageSightings as i, type XConnection as j, type XPost as k, limits as l, type XProfile as m, type XUser as n, type XUserLookupInput as o, imageAssetArtifactSchema as p, imageComparisonSchema as q, imageExtractionSchema as r, imageFieldSchema as s, imageFieldsSchema as t, imageInspectionSchema as u, imageReferenceSchema as v, imageRequestSchema as w, imageSightingsSchema as x, imageUploadRequestSchema as y, imageUploadsSchema as z };

package/dist/{offers-BoV4ryUc.d.ts → offers-CYeN_I0Y.d.ts}

@@ -1,6 +1,6 @@
 import * as z from 'zod';
-import { y as ResourceHandle } from './schema-CZ6Rj0ZF.js';
-import { l as AuthoringIdentity } from './groups-CqcA2Ycs.js';
+import { R as ResourceHandle } from './tracker-data-esm3WG8R.js';
+import { Z as AuthoringIdentity } from './accounts-nz3mzfRQ.js';
 
 declare const badgePropertiesSchema: z.ZodObject<{
     name: z.ZodString;
@@ -65,6 +65,16 @@ declare const memberBadgesSchema: z.ZodObject<{
         awardedAt: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/** `GET /v1/badges/catalog`: the active catalog. */
+declare const badgeCatalogSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+        image: z.ZodString;
+        id: z.ZodString;
+        key: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const badgeMutationSchema: z.ZodObject<{
     actionId: z.ZodString;
     reason: z.ZodString;
@@ -75,10 +85,15 @@ declare const badgeMutationResultSchema: z.ZodObject<{
     awarded: z.ZodBoolean;
     changed: z.ZodBoolean;
 }, z.core.$strip>;
+/** @compat output */
 type Badge = z.infer<typeof badgeSchema>;
 type ManagedBadge = z.infer<typeof managedBadgeSchema>;
+/** @compat output */
 type MemberBadge = z.infer<typeof memberBadgeSchema>;
+/** @compat output */
 type MemberBadges = z.infer<typeof memberBadgesSchema>;
+/** The active badge catalog, as `GET /v1/badges/catalog` returns it. */
+type BadgeCatalog = z.infer<typeof badgeCatalogSchema>;
 
 declare const offerPriceSchema: z.ZodObject<{
     kind: z.ZodDefault<z.ZodLiteral<"points">>;
@@ -774,7 +789,10 @@ declare const redemptionCancellationSchema: z.ZodObject<{
     revision: z.ZodNumber;
     reason: z.ZodString;
 }, z.core.$strict>;
-/** Define one points-priced offer for a tier reward. The reward title is used when no title is set. */
+/**
+ * Define one points-priced offer for a tier reward. The reward title is used when no title is set.
+ * @deprecated Import `defineOffer` from `@domino-sdk/relay/authoring`, which also refuses badge and group rewards when defined. Removed from `@domino-sdk/relay/schema` in 2.0.0.
+ */
 declare function defineOffer(input: OfferAuthoring & AuthoringIdentity): {
     title: string;
     enabled: boolean;
@@ -830,4 +848,4 @@ declare function defineOffer(input: OfferAuthoring & AuthoringIdentity): {
     })[] | undefined;
 } & ResourceHandle<"offer">;
 
-export { offerSchema as A, type Badge as B, redeemOfferSchema as C, redemptionCancellationSchema as D, redemptionPageSchema as E, redemptionQuerySchema as F, redemptionSchema as G, type ManagedBadge as M, type Offer as O, type RedeemOfferInput as R, type MemberBadge as a, type MemberBadges as b, type OfferDefinition as c, type OfferPrice as d, type Redemption as e, badgeDeclarationSchema as f, defineOffer as g, type OfferAuthoring as h, type RedemptionPage as i, type RedemptionQuery as j, badgeArtifactSchema as k, badgeMutationResultSchema as l, badgeMutationSchema as m, badgePropertiesSchema as n, badgeSchema as o, createBadgeSchema as p, managedBadgeSchema as q, memberBadgeSchema as r, memberBadgesSchema as s, offerArtifactSchema as t, offerAuthoringSchema as u, offerAvailabilitySchema as v, offerControlSchema as w, offerDefinitionSchema as x, offerLimitSchema as y, offerPriceSchema as z };
+export { offerLimitSchema as A, type Badge as B, offerPriceSchema as C, offerSchema as D, redeemOfferSchema as E, redemptionCancellationSchema as F, redemptionPageSchema as G, redemptionQuerySchema as H, redemptionSchema as I, type ManagedBadge as M, type Offer as O, type RedeemOfferInput as R, type BadgeCatalog as a, type MemberBadge as b, type MemberBadges as c, type OfferDefinition as d, type OfferPrice as e, type Redemption as f, badgeDeclarationSchema as g, type OfferAuthoring as h, type RedemptionPage as i, type RedemptionQuery as j, badgeArtifactSchema as k, badgeCatalogSchema as l, badgeMutationResultSchema as m, badgeMutationSchema as n, badgePropertiesSchema as o, badgeSchema as p, createBadgeSchema as q, defineOffer as r, managedBadgeSchema as s, memberBadgeSchema as t, memberBadgesSchema as u, offerArtifactSchema as v, offerAuthoringSchema as w, offerAvailabilitySchema as x, offerControlSchema as y, offerDefinitionSchema as z };