@vercel/board 0.0.0 → 0.16.0

package/dist/provider-BGjz-mDa.d.mts

@@ -0,0 +1,2473 @@
+import { n as AccessSummary } from "./access-CV96SYgr.mjs";
+import { i as Attachment } from "./schemas-CWxs3ECJ.mjs";
+import { _ as ExternalFile, a as ExternalCopy, g as ExternalEvent, h as ExternalAuthor, o as Message, p as BoardEvent, r as Channel, t as Actor, v as ExternalLink, y as Link } from "./reducers-B_vUGQRp.mjs";
+import { z } from "zod";
+//#region src/api/routes.d.ts
+/**
+ * A message's, schedule's, or cursor's ID: a string clients pass back as they got it, and never
+ * parse, compare, or count with. Each backend picks its own; a board on `a2()` writes decimals.
+ */
+declare const Ref: z.ZodString;
+/** A sync target as the board that syncs it resolved it: a platform channel to start a thread in, or a thread to join. */
+declare const ResolvedSyncTarget: z.ZodObject<{
+  target: z.ZodString;
+  kind: z.ZodEnum<{
+    channel: "channel";
+    thread: "thread";
+  }>;
+}, z.core.$strip>;
+/** Shared by `/messages` and `/events`. */
+declare const Filters$1: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  re: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+  mentions: z.ZodOptional<z.ZodString>;
+  label: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<readonly [string, null] | readonly [string, string[]], string>>>>>;
+  from: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const MessagesQuery: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  re: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+  mentions: z.ZodOptional<z.ZodString>;
+  label: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<readonly [string, null] | readonly [string, string[]], string>>>>>;
+  from: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+  after: z.ZodOptional<z.ZodString>;
+  before: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/** `limit` counts threads: each thread with a matching message, by its latest reply. */
+declare const ThreadsQuery: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  re: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+  mentions: z.ZodOptional<z.ZodString>;
+  label: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<readonly [string, null] | readonly [string, string[]], string>>>>>;
+  from: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+  after: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const EventsQuery: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  re: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+  mentions: z.ZodOptional<z.ZodString>;
+  label: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<readonly [string, null] | readonly [string, string[]], string>>>>>;
+  from: z.ZodOptional<z.ZodString>;
+  text: z.ZodOptional<z.ZodString>;
+  after: z.ZodOptional<z.ZodString>;
+  wait: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  all: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+declare const PostBody: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  re: z.ZodOptional<z.ZodString>;
+  text: z.ZodDefault<z.ZodString>;
+  labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  noSync: z.ZodOptional<z.ZodBoolean>;
+  sync: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    target: z.ZodString;
+    kind: z.ZodEnum<{
+      channel: "channel";
+      thread: "thread";
+    }>;
+  }, z.core.$strip>]>>>;
+  id: z.ZodOptional<z.ZodString>;
+  attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * A message to post later, as the caller: once (`in` or `at`), or repeating
+ * (`every`, starting `at` or `in` from now, or one `every` from now), until
+ * `until`, `for` after the first send, or `times` sends. A repeat with no stop
+ * runs until it's canceled.
+ */
+declare const ScheduleBody: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  re: z.ZodOptional<z.ZodString>;
+  text: z.ZodDefault<z.ZodString>;
+  labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  noSync: z.ZodOptional<z.ZodBoolean>;
+  attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  in: z.ZodOptional<z.ZodString>;
+  at: z.ZodOptional<z.ZodString>;
+  every: z.ZodOptional<z.ZodString>;
+  until: z.ZodOptional<z.ZodString>;
+  for: z.ZodOptional<z.ZodString>;
+  times: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const SchedulesQuery: z.ZodObject<{
+  re: z.ZodOptional<z.ZodString>;
+  channel: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+  all: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+declare const SyncBody: z.ZodObject<{
+  target: z.ZodString;
+}, z.core.$strip>;
+declare const InboxQuery: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/** How many watchers one registration holds: the board matches every event against every tail. */
+declare const REGISTERED_WATCHERS_MAX = 32;
+/** What a board on `http()` registers with the board it uses: its watchers' tails, and where to wake it. */
+declare const RegisterBody: z.ZodObject<{
+  url: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+  watch: z.ZodRecord<z.ZodString, z.ZodObject<{
+    tail: z.ZodString;
+    when: z.ZodDefault<z.ZodEnum<{
+      enters: "enters";
+      matches: "matches";
+    }>>;
+  }, z.core.$strip>>;
+  sync: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    platform: z.ZodString;
+    signIn: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** A pull of the caller's matches: at most `limit`, waiting up to `wait` seconds for one. */
+declare const MatchesQuery: z.ZodObject<{
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  wait: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/** How a pulled match went: its lease, and an error to try again, or `skip` to drop it. */
+declare const AckBody: z.ZodObject<{
+  lease: z.ZodString;
+  error: z.ZodOptional<z.ZodString>;
+  skip: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * What to read from a platform without syncing it: a channel (`#name` or an ID),
+ * a thread (`C0123:1727000000.123456`), or a message permalink (its thread).
+ */
+declare const SourceReadQuery: z.ZodObject<{
+  target: z.ZodString;
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const IdentityUnlinkBody: z.ZodObject<{
+  actor: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A platform's write, as its platform author, with where it came from: only a caller with `sync` in
+ * the channel it lands in may make one. Posts are idempotent by `id`, derived from the platform
+ * event; every other op finds the message it changes from its `origin`.
+ */
+declare const SyncImportBody: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+  from: z.ZodNullable<z.ZodString>;
+  op: z.ZodLiteral<"post">;
+  origin: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+    channel: z.ZodOptional<z.ZodString>;
+    thread: z.ZodString;
+    subthread: z.ZodNullable<z.ZodString>;
+    message: z.ZodString;
+    context: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>>;
+  source: z.ZodOptional<z.ZodObject<{
+    key: z.ZodString;
+    channel: z.ZodString;
+    thread: z.ZodString;
+  }, z.core.$strip>>;
+  channel: z.ZodOptional<z.ZodString>;
+  re: z.ZodOptional<z.ZodString>;
+  text: z.ZodDefault<z.ZodString>;
+  labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  noSync: z.ZodOptional<z.ZodBoolean>;
+  attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    url: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodObject<{
+      author: z.ZodString;
+      text: z.ZodString;
+      createdAt: z.ZodNullable<z.ZodString>;
+      files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    unavailable: z.ZodNullable<z.ZodString>;
+    message: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>>;
+  id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+  from: z.ZodNullable<z.ZodString>;
+  origin: z.ZodOptional<z.ZodObject<{
+    thread: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  message: z.ZodOptional<z.ZodString>;
+  op: z.ZodLiteral<"edit">;
+  text: z.ZodString;
+  source: z.ZodOptional<z.ZodObject<{
+    key: z.ZodString;
+    channel: z.ZodString;
+    thread: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+  from: z.ZodNullable<z.ZodString>;
+  origin: z.ZodOptional<z.ZodObject<{
+    thread: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  message: z.ZodOptional<z.ZodString>;
+  op: z.ZodLiteral<"delete">;
+}, z.core.$strip>, z.ZodObject<{
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+  from: z.ZodNullable<z.ZodString>;
+  origin: z.ZodOptional<z.ZodObject<{
+    thread: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  message: z.ZodOptional<z.ZodString>;
+  op: z.ZodLiteral<"react">;
+  emoji: z.ZodString;
+  remove: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+  from: z.ZodNullable<z.ZodString>;
+  origin: z.ZodOptional<z.ZodObject<{
+    thread: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  message: z.ZodOptional<z.ZodString>;
+  op: z.ZodLiteral<"labels">;
+  set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+  from: z.ZodNullable<z.ZodString>;
+  origin: z.ZodOptional<z.ZodObject<{
+    thread: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  message: z.ZodOptional<z.ZodString>;
+  op: z.ZodLiteral<"links">;
+  links: z.ZodArray<z.ZodObject<{
+    url: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodObject<{
+      author: z.ZodString;
+      text: z.ZodString;
+      createdAt: z.ZodNullable<z.ZodString>;
+      files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    unavailable: z.ZodNullable<z.ZodString>;
+    message: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  op: z.ZodLiteral<"seen">;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+}, z.core.$strip>], "op">;
+/** What sync did on a platform, about a board message: it landed, its files did, it gave up, or its thread syncs with a target. */
+declare const SyncReceiptBody: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"message">;
+  message: z.ZodString;
+  target: z.ZodString;
+  external: z.ZodObject<{
+    thread: z.ZodString;
+    message: z.ZodString;
+    asUser: z.ZodOptional<z.ZodLiteral<true>>;
+  }, z.core.$strip>;
+  files: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"files">;
+  message: z.ZodString;
+  target: z.ZodString;
+  files: z.ZodNullable<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"failed">;
+  message: z.ZodString;
+  target: z.ZodString;
+  error: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"thread">;
+  message: z.ZodString;
+  target: z.ZodString;
+  targetKind: z.ZodEnum<{
+    channel: "channel";
+    thread: "thread";
+  }>;
+  cause: z.ZodEnum<{
+    config: "config";
+    request: "request";
+  }>;
+}, z.core.$strip>], "kind">;
+/** What sync looks up by platform ID: a thread or message, who an account is, and a person's accounts. */
+declare const SyncFindQuery: z.ZodObject<{
+  code: z.ZodOptional<z.ZodString>;
+  post: z.ZodOptional<z.ZodString>;
+  thread: z.ZodOptional<z.ZodString>;
+  message: z.ZodOptional<z.ZodString>;
+  account: z.ZodOptional<z.ZodString>;
+  person: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SyncCopiesQuery: z.ZodObject<{
+  message: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** A person's own roots since `since`, in epoch milliseconds. */
+declare const SyncRootsQuery: z.ZodObject<{
+  by: z.ZodString;
+  since: z.ZodCoercedNumber<unknown>;
+}, z.core.$strip>;
+/** Platform events for a sync key's inbox, each with the platform's own ID for it, which dedupes it. */
+declare const InboxPushBody: z.ZodObject<{
+  events: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      channel: z.ZodString;
+      thread: z.ZodString;
+      subthread: z.ZodNullable<z.ZodString>;
+      kind: z.ZodLiteral<"message">;
+      message: z.ZodString;
+      isRoot: z.ZodBoolean;
+      text: z.ZodString;
+      context: z.ZodNullable<z.ZodString>;
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodNullable<z.ZodString>;
+        isBot: z.ZodBoolean;
+      }, z.core.$strip>;
+      files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+          audio: "audio";
+          file: "file";
+          image: "image";
+          video: "video";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        url: z.ZodOptional<z.ZodString>;
+        fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      }, z.core.$strip>>>;
+      links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        thread: z.ZodString;
+        message: z.ZodString;
+        snapshot: z.ZodNullable<z.ZodObject<{
+          author: z.ZodString;
+          text: z.ZodString;
+          createdAt: z.ZodNullable<z.ZodString>;
+          files: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodNullable<z.ZodString>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+      channel: z.ZodString;
+      thread: z.ZodString;
+      subthread: z.ZodNullable<z.ZodString>;
+      kind: z.ZodLiteral<"edited">;
+      message: z.ZodString;
+      text: z.ZodString;
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodNullable<z.ZodString>;
+        isBot: z.ZodBoolean;
+      }, z.core.$strip>;
+      links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        thread: z.ZodString;
+        message: z.ZodString;
+        snapshot: z.ZodNullable<z.ZodObject<{
+          author: z.ZodString;
+          text: z.ZodString;
+          createdAt: z.ZodNullable<z.ZodString>;
+          files: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodNullable<z.ZodString>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>>;
+      linksOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+      channel: z.ZodString;
+      thread: z.ZodString;
+      subthread: z.ZodNullable<z.ZodString>;
+      kind: z.ZodLiteral<"deleted">;
+      message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      channel: z.ZodString;
+      thread: z.ZodString;
+      subthread: z.ZodNullable<z.ZodString>;
+      kind: z.ZodLiteral<"reaction">;
+      message: z.ZodString;
+      emoji: z.ZodString;
+      added: z.ZodBoolean;
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodNullable<z.ZodString>;
+        isBot: z.ZodBoolean;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      channel: z.ZodString;
+      thread: z.ZodString;
+      kind: z.ZodLiteral<"lifecycle">;
+      type: z.ZodString;
+      title: z.ZodString;
+      url: z.ZodNullable<z.ZodString>;
+      labels: z.ZodRecord<z.ZodString, z.ZodString>;
+      unset: z.ZodArray<z.ZodString>;
+      owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      reply: z.ZodNullable<z.ZodString>;
+      createRoot: z.ZodBoolean;
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodNullable<z.ZodString>;
+        isBot: z.ZodBoolean;
+      }, z.core.$strip>;
+    }, z.core.$strip>], "kind">;
+    raw: z.ZodUnknown;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const InboxNextQuery: z.ZodObject<{
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+declare const InboxAckBody: z.ZodObject<{
+  lease: z.ZodString;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A one-time code for linking an account on sync entry `sync`: a person's own, for themselves. */
+declare const SyncCodeBody: z.ZodObject<{
+  sync: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A platform account, linked to whoever a code was issued to: one posted from the account, or
+ * carried through its sign-in. `message` is the platform message that posted it.
+ */
+declare const SyncAccountBody: z.ZodObject<{
+  sync: z.ZodString;
+  account: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    isBot: z.ZodBoolean;
+    avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+  }, z.core.$strip>;
+  code: z.ZodString;
+  message: z.ZodOptional<z.ZodString>;
+  method: z.ZodOptional<z.ZodEnum<{
+    code: "code";
+    consent: "consent";
+  }>>;
+}, z.core.$strip>;
+/** A sign-in that carries a code, on the board whose sync runs the entry. */
+declare const SignInQuery: z.ZodObject<{
+  sync: z.ZodString;
+  code: z.ZodString;
+}, z.core.$strip>;
+declare const SyncUnlinkBody: z.ZodObject<{
+  account: z.ZodString;
+}, z.core.$strip>;
+/** A direct upload, before its bytes: what the file will be called, its type, and its exact size. */
+declare const UploadStartBody: z.ZodObject<{
+  name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  size: z.ZodNumber;
+}, z.core.$strip>;
+/** Where to send a direct upload's bytes: `PUT` the file to `url` with `headers` (its `content-type` included), before `expiresAt`, then finish it. */
+type UploadTicket = {
+  id: string;
+  url: string;
+  headers: Record<string, string>;
+  expiresAt: string;
+};
+declare const EditBody: z.ZodObject<{
+  text: z.ZodString;
+}, z.core.$strip>;
+declare const DeleteBody: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+/** `status`: what Slack shows in place of "Typing…" (WhatsApp and GitHub ignore it). */
+declare const TypingBody: z.ZodOptional<z.ZodObject<{
+  status: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ReactBody: z.ZodObject<{
+  emoji: z.ZodString;
+  remove: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const LabelBody: z.ZodObject<{
+  set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type FiltersInput = z.input<typeof Filters$1>;
+type SyncImportInput = z.input<typeof SyncImportBody>;
+type SyncReceiptInput = z.input<typeof SyncReceiptBody>;
+type SyncFindInput = z.input<typeof SyncFindQuery>;
+type SyncAccountInput = z.input<typeof SyncAccountBody>;
+type MessagesQueryInput = z.input<typeof MessagesQuery>;
+type ThreadsQueryInput = z.input<typeof ThreadsQuery>;
+type EventsQueryInput = z.input<typeof EventsQuery>;
+type PostInput = z.input<typeof PostBody>;
+type ScheduleInput = z.input<typeof ScheduleBody>;
+type ScheduleBodyOutput = z.output<typeof ScheduleBody>;
+type SchedulesQueryInput = z.input<typeof SchedulesQuery>;
+type SchedulesQueryOutput = z.output<typeof SchedulesQuery>;
+/** A scheduled message. It posts as `by`, its creator; each message it posts carries `schedule: { id, n }`. */
+type ScheduleView = {
+  id: string;
+  channel: string;
+  /** The thread it replies in, or null when each send starts a new thread in `channel`. */
+  re: string | null;
+  text: string;
+  labels: Record<string, string>;
+  noSync: boolean;
+  attachments: {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+  }[];
+  first: string;
+  /** Milliseconds between sends, or null for once. */
+  every: number | null;
+  until: string | null;
+  times: number | null;
+  /** Sends posted so far. */
+  sent: number;
+  /** When the next send is due; null once it's done or canceled. */
+  next: string | null;
+  /** The last message it posted. */
+  last: string | null;
+  state: 'pending' | 'done' | 'canceled';
+  canceled: {
+    by: {
+      actor: string;
+      principal: string;
+      profile: string | null;
+      session: string | null;
+    };
+    reason: 'canceled' | 'thread_deleted' | 'dropped' | 'revoked';
+  } | null;
+  by: {
+    actor: string;
+    principal: string;
+    profile: string | null;
+    session: string | null;
+  };
+  author: ActorView;
+  createdAt: string;
+};
+/** The person a platform account is linked to (`actor.linked`). */
+type PersonView = {
+  id: string;
+  handle: string;
+  name: string;
+  avatar: string | null;
+};
+/**
+ * `kind` says who wrote it: a `person` or a platform user (`external`), an agent (`profile`), or a deployment or workflow.
+ * `person` is who a linked platform account belongs to.
+ */
+type ActorView = Pick<Actor, 'kind' | 'handle' | 'name' | 'avatar'> & {
+  person?: PersonView;
+};
+/** A message as clients see it: its IDs are refs, and `version` says which of two views of it is newer. */
+type MessageView = Omit<Message, 'id' | 're' | 'replyTo' | 'links' | 'schedule' | 'version'> & {
+  id: string;
+  /** The thread's root, or null for a root. */
+  re: string | null;
+  /** The exact message replied to, when it isn't the root. */
+  replyTo: string | null;
+  /** Grows with each change to this message: of two views of it, the one with the higher version is newer. */
+  version: number;
+  links: LinkView[];
+  /** Set when a schedule posted it: the schedule's ID and which send this was, from 0. */
+  schedule?: {
+    id: string;
+    n: number;
+  };
+  author: ActorView | null;
+};
+/** A link in a message: a board message it names is a ref. */
+type LinkView = Omit<Link, 'message'> & {
+  message: string | null;
+};
+/** An event's payload as clients see it: message IDs are refs. */
+type PayloadView<P> = { [K in keyof P]: K extends 'id' | 're' | 'replyTo' ? P[K] extends number ? string : P[K] extends number | null ? string | null : P[K] : K extends 'links' ? LinkView[] : K extends 'schedule' ? P[K] extends undefined ? undefined : {
+  id: string;
+  n: number;
+} | Exclude<P[K], object> : P[K]; };
+/** A board event as subscribers get it. Checking `type` narrows `payload` to that event's. */
+type BoardEventView = BoardEvent extends (infer E) ? E extends {
+  type: infer T;
+  payload: infer P;
+} ? {
+  /** Where this event is in the board's order: pass it as `after` to read on from here. */
+  cursor: string;
+  type: T;
+  createdAt: string;
+  payload: PayloadView<P>;
+  /** The message the event concerns, as it is after the event. */
+  message?: MessageView;
+  /** Who did it, for events with an author: a reaction's reactor, a label's setter. */
+  actor?: ActorView & {
+    id: string;
+  };
+} : never : never;
+type Discovery = {
+  version: string;
+  url: string;
+  audience: string;
+  team_id: string | null;
+  project_id: string | null;
+  /** The board's sync entries: `key` names its webhook and inbox, `platform` is e.g. `slack`. */
+  sync: {
+    key: string;
+    platform: string;
+  }[];
+};
+/** Watchers a board on `http()` registered here: one registration per principal. */
+type RegistrationView = {
+  /** The principal that registered. Its watchers write as it, with their IDs as profiles. */
+  owner: string;
+  /** Where it's woken: `<url>/wake`. `null` when it pulls on its own. */
+  url: string | null;
+  watch: Record<string, {
+    tail: string;
+    when: 'matches' | 'enters';
+  }>;
+  /** Its sync entries. With any, its sync gets every event it delivers to platforms, as matches of watcher `@sync`. */
+  sync: {
+    key: string;
+    platform: string;
+    signIn: boolean;
+  }[];
+  /** Every wake-up carries it, so the board can tell its registration is stale. */
+  hash: string;
+};
+/** One match, leased to the registrant that pulled it. */
+type MatchView = {
+  /** The match's ID, which its watcher's writes derive their IDs from. */
+  id: string;
+  watcher: string;
+  thread: string;
+  /** Acks name it. A lease that ran out is someone else's next try. */
+  lease: string;
+  /** How many tries came before this one. */
+  attempt: number;
+  /** The event, as `vb tail --json` prints it, as the registrant may see it. */
+  event: BoardEventView;
+};
+type Me = {
+  actor: string;
+  principal: string;
+  kind: Actor['kind'];
+  handle: string;
+  name: string;
+  avatar: string | null;
+  profile: string | null;
+  session: string | null;
+  expiresAt: string | null;
+  /** What you may do in each channel pattern, implications included: `{ '*': [...every permission] }` is full access. */
+  can: AccessSummary;
+};
+/** A platform account linked to you, as `GET /identity` lists it. */
+type LinkedAccount = {
+  actor: string;
+  handle: string | null;
+  name: string | null;
+  method: 'code' | 'consent';
+  at: string;
+};
+type IdentityView = {
+  principal: string;
+  links: LinkedAccount[];
+  /** The sync entries you haven't linked an account on. Boards older than it leave it out. */
+  unlinked?: string[];
+  cursor: string;
+};
+/**
+ * How to prove an account is yours: post `code` from it anywhere the board syncs before
+ * `expiresAt`, or, when the entry signs people in, open `signIn` and approve: it carries the code.
+ */
+type SyncCodeView = {
+  code: string;
+  expiresAt: string;
+  signIn?: string;
+};
+/** A thread's sync: its root, where it lives, its targets, and the platform thread it is on each. */
+type SyncThreadView = {
+  thread: string;
+  root: string;
+  channel: string;
+  targets: string[];
+  external: Record<string, string>;
+};
+/** What a platform ID is on the board. Each answers only when it was asked. */
+type SyncFindView = {
+  /** The board thread a platform thread belongs to. */
+  thread: string | null;
+  /** The board message a platform message is a copy of, or came in as. */
+  message: string | null;
+  /** Who a platform account is linked to, and how. */
+  person: {
+    id: string;
+    method: 'code' | 'consent';
+  } | null;
+  /** The platform accounts linked to a person, and how. */
+  accounts: {
+    id: string;
+    method: 'code' | 'consent';
+  }[];
+  /** Who a live code was issued to. */
+  holder: string | null;
+};
+/** A message's copies, by target: where it went, or came from, on each platform. */
+type SyncCopiesView = {
+  copies: Record<string, Record<string, ExternalCopy>>;
+};
+/** A platform event pulled from the caller's inbox, leased to it until it acks. */
+type InboxItem = {
+  id: string;
+  key: string;
+  /** The platform thread: its events come one at a time, in order. */
+  thread: string;
+  lease: string;
+  /** How many tries came before this one. */
+  attempt: number;
+  event: z.infer<typeof ExternalEvent>;
+  raw: unknown;
+};
+type ChannelView = Channel;
+type MessagesPage = {
+  messages: MessageView[];
+  cursor: string;
+};
+type ThreadView = {
+  message: MessageView;
+  replies: MessageView[];
+  cursor: string;
+  /** The pending schedules that reply in this thread. Boards older than schedules leave it out. */
+  schedules?: ScheduleView[];
+};
+/** A thread at a glance: its root, how many replies it has, and the latest one (null when none). Deleted replies don't count. */
+type ThreadSummaryView = {
+  message: MessageView;
+  replies: number;
+  last: MessageView | null;
+};
+type ThreadsPage = {
+  threads: ThreadSummaryView[];
+  cursor: string;
+};
+type EventsPage = {
+  events: BoardEventView[];
+  cursor: string;
+};
+/** The platform threads that now show typing: those the thread is synced to, minus any that failed. */
+type TypingResult = {
+  targets: string[];
+};
+/** A platform message read on demand: nothing about it is stored on the board. */
+type SourceMessage = {
+  /** The platform's message ID (Slack's `ts`). */
+  id: string;
+  /** The thread it's in, as a target `vb sources <key> read` reads: `C0123:1727000000.123456`. */
+  thread: string;
+  author: string;
+  text: string;
+  createdAt: string | null;
+  /** Replies under it, when it starts a thread. */
+  replies: number;
+  files: {
+    name: string;
+    url: string | null;
+  }[];
+};
+/** A channel or thread read from a platform, oldest message first. */
+type SourceRead = {
+  /** The channel's ID, and its name when the platform gave one. */
+  channel: string;
+  name: string | null;
+  /** Set when a thread was read. */
+  thread: string | null;
+  messages: SourceMessage[];
+  /** The platform has more than `limit`: older messages in a channel, later replies in a thread. */
+  more: boolean;
+};
+type ApiError = {
+  error: {
+    code: string;
+    message: string;
+  };
+};
+/** A raw platform event, as `GET /inbox/:key` returns it. */
+type InboxEntry = {
+  id: string;
+  channel: string;
+  createdAt: string;
+  sync: string;
+  event: {
+    kind: string;
+    thread: string;
+    [field: string]: unknown;
+  };
+  raw: unknown;
+};
+/** The route table: method, path, and the schemas that validate input. */
+declare const routes: {
+  /** Where the board is, its project, and the sync entries it links accounts on. No token. */
+  readonly discovery: {
+    readonly method: 'GET';
+    readonly path: '/';
+  };
+  readonly me: {
+    readonly method: 'GET';
+    readonly path: '/me';
+  };
+  readonly channels: {
+    readonly method: 'GET';
+    readonly path: '/channels';
+  };
+  readonly actors: {
+    readonly method: 'GET';
+    readonly path: '/actors';
+  };
+  readonly messages: {
+    readonly method: 'GET';
+    readonly path: '/messages';
+    readonly query: z.ZodObject<{
+      channel: z.ZodOptional<z.ZodString>;
+      re: z.ZodOptional<z.ZodString>;
+      by: z.ZodOptional<z.ZodString>;
+      mentions: z.ZodOptional<z.ZodString>;
+      label: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<readonly [string, null] | readonly [string, string[]], string>>>>>;
+      from: z.ZodOptional<z.ZodString>;
+      text: z.ZodOptional<z.ZodString>;
+      after: z.ZodOptional<z.ZodString>;
+      before: z.ZodOptional<z.ZodString>;
+      limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+  };
+  readonly message: {
+    readonly method: 'GET';
+    readonly path: '/messages/:id';
+  };
+  /** Threads with a matching message, one summary each, by latest activity. */
+  readonly threads: {
+    readonly method: 'GET';
+    readonly path: '/threads';
+    readonly query: z.ZodObject<{
+      channel: z.ZodOptional<z.ZodString>;
+      re: z.ZodOptional<z.ZodString>;
+      by: z.ZodOptional<z.ZodString>;
+      mentions: z.ZodOptional<z.ZodString>;
+      label: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<readonly [string, null] | readonly [string, string[]], string>>>>>;
+      from: z.ZodOptional<z.ZodString>;
+      text: z.ZodOptional<z.ZodString>;
+      after: z.ZodOptional<z.ZodString>;
+      limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+  };
+  readonly post: {
+    readonly method: 'POST';
+    readonly path: '/messages';
+    readonly body: z.ZodObject<{
+      channel: z.ZodOptional<z.ZodString>;
+      re: z.ZodOptional<z.ZodString>;
+      text: z.ZodDefault<z.ZodString>;
+      labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      noSync: z.ZodOptional<z.ZodBoolean>;
+      sync: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        target: z.ZodString;
+        kind: z.ZodEnum<{
+          channel: "channel";
+          thread: "thread";
+        }>;
+      }, z.core.$strip>]>>>;
+      id: z.ZodOptional<z.ZodString>;
+      attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+  };
+  readonly edit: {
+    readonly method: 'POST';
+    readonly path: '/messages/:id/edit';
+    readonly body: z.ZodObject<{
+      text: z.ZodString;
+    }, z.core.$strip>;
+  };
+  readonly delete: {
+    readonly method: 'POST';
+    readonly path: '/messages/:id/delete';
+    readonly body: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+  };
+  readonly react: {
+    readonly method: 'POST';
+    readonly path: '/messages/:id/reactions';
+    readonly body: z.ZodObject<{
+      emoji: z.ZodString;
+      remove: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+  };
+  readonly label: {
+    readonly method: 'POST';
+    readonly path: '/messages/:id/labels';
+    readonly body: z.ZodObject<{
+      set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+  };
+  /** Attaches the thread to a sync target, recording a `thread` receipt: needs `sync` where the thread is. */
+  readonly sync: {
+    readonly method: 'POST';
+    readonly path: '/messages/:id/sync';
+    readonly body: z.ZodObject<{
+      target: z.ZodString;
+    }, z.core.$strip>;
+  };
+  /** Ephemeral: shows typing in the thread's synced platform threads, and writes nothing to the log. Needs `post` where the thread is. */
+  readonly typing: {
+    readonly method: 'POST';
+    readonly path: '/messages/:id/typing';
+    readonly body: z.ZodOptional<z.ZodObject<{
+      status: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  };
+  /** Posts a message later, as the caller: needs a scheduler. */
+  readonly schedule: {
+    readonly method: 'POST';
+    readonly path: '/schedules';
+    readonly body: z.ZodObject<{
+      channel: z.ZodOptional<z.ZodString>;
+      re: z.ZodOptional<z.ZodString>;
+      text: z.ZodDefault<z.ZodString>;
+      labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      noSync: z.ZodOptional<z.ZodBoolean>;
+      attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      in: z.ZodOptional<z.ZodString>;
+      at: z.ZodOptional<z.ZodString>;
+      every: z.ZodOptional<z.ZodString>;
+      until: z.ZodOptional<z.ZodString>;
+      for: z.ZodOptional<z.ZodString>;
+      times: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+  };
+  readonly schedules: {
+    readonly method: 'GET';
+    readonly path: '/schedules';
+    readonly query: z.ZodObject<{
+      re: z.ZodOptional<z.ZodString>;
+      channel: z.ZodOptional<z.ZodString>;
+      by: z.ZodOptional<z.ZodString>;
+      all: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    }, z.core.$strip>;
+  };
+  /** Its creator, or manage in its channel, may cancel a schedule. Canceling one that's done is a no-op. */
+  readonly cancelSchedule: {
+    readonly method: 'POST';
+    readonly path: '/schedules/:id/cancel';
+  };
+  /** The caller's own post with the client ID it gave: what `POST /messages` answered, for telling a retry before posting. */
+  readonly posted: {
+    readonly method: 'GET';
+    readonly path: '/posts/:id';
+  };
+  /** Raw platform events in a sync key's inbox, newest first: the caller's own, and the board's with `sync` everywhere. */
+  readonly inbox: {
+    readonly method: 'GET';
+    readonly path: '/inbox/:key';
+    readonly query: z.ZodObject<{
+      channel: z.ZodOptional<z.ZodString>;
+      limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+  };
+  /** Pushes platform events into the caller's inbox for a sync key, deduplicated by their platform IDs. */
+  readonly inboxPush: {
+    readonly method: 'POST';
+    readonly path: '/inbox/:key';
+    readonly body: z.ZodObject<{
+      events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          channel: z.ZodString;
+          thread: z.ZodString;
+          subthread: z.ZodNullable<z.ZodString>;
+          kind: z.ZodLiteral<"message">;
+          message: z.ZodString;
+          isRoot: z.ZodBoolean;
+          text: z.ZodString;
+          context: z.ZodNullable<z.ZodString>;
+          author: z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+            name: z.ZodString;
+            avatar: z.ZodNullable<z.ZodString>;
+            isBot: z.ZodBoolean;
+          }, z.core.$strip>;
+          files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+              audio: "audio";
+              file: "file";
+              image: "image";
+              video: "video";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            url: z.ZodOptional<z.ZodString>;
+            fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+          }, z.core.$strip>>>;
+          links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            thread: z.ZodString;
+            message: z.ZodString;
+            snapshot: z.ZodNullable<z.ZodObject<{
+              author: z.ZodString;
+              text: z.ZodString;
+              createdAt: z.ZodNullable<z.ZodString>;
+              files: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                url: z.ZodNullable<z.ZodString>;
+              }, z.core.$strip>>;
+            }, z.core.$strip>>;
+          }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+          channel: z.ZodString;
+          thread: z.ZodString;
+          subthread: z.ZodNullable<z.ZodString>;
+          kind: z.ZodLiteral<"edited">;
+          message: z.ZodString;
+          text: z.ZodString;
+          author: z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+            name: z.ZodString;
+            avatar: z.ZodNullable<z.ZodString>;
+            isBot: z.ZodBoolean;
+          }, z.core.$strip>;
+          links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            thread: z.ZodString;
+            message: z.ZodString;
+            snapshot: z.ZodNullable<z.ZodObject<{
+              author: z.ZodString;
+              text: z.ZodString;
+              createdAt: z.ZodNullable<z.ZodString>;
+              files: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                url: z.ZodNullable<z.ZodString>;
+              }, z.core.$strip>>;
+            }, z.core.$strip>>;
+          }, z.core.$strip>>>;
+          linksOnly: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+          channel: z.ZodString;
+          thread: z.ZodString;
+          subthread: z.ZodNullable<z.ZodString>;
+          kind: z.ZodLiteral<"deleted">;
+          message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+          channel: z.ZodString;
+          thread: z.ZodString;
+          subthread: z.ZodNullable<z.ZodString>;
+          kind: z.ZodLiteral<"reaction">;
+          message: z.ZodString;
+          emoji: z.ZodString;
+          added: z.ZodBoolean;
+          author: z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+            name: z.ZodString;
+            avatar: z.ZodNullable<z.ZodString>;
+            isBot: z.ZodBoolean;
+          }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+          channel: z.ZodString;
+          thread: z.ZodString;
+          kind: z.ZodLiteral<"lifecycle">;
+          type: z.ZodString;
+          title: z.ZodString;
+          url: z.ZodNullable<z.ZodString>;
+          labels: z.ZodRecord<z.ZodString, z.ZodString>;
+          unset: z.ZodArray<z.ZodString>;
+          owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+          reply: z.ZodNullable<z.ZodString>;
+          createRoot: z.ZodBoolean;
+          author: z.ZodObject<{
+            id: z.ZodString;
+            handle: z.ZodString;
+            name: z.ZodString;
+            avatar: z.ZodNullable<z.ZodString>;
+            isBot: z.ZodBoolean;
+          }, z.core.$strip>;
+        }, z.core.$strip>], "kind">;
+        raw: z.ZodUnknown;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /** The caller's next inbox events, leased to it, one platform thread at a time and in order. */
+  readonly inboxNext: {
+    readonly method: 'GET';
+    readonly path: '/inbox/:key/next';
+    readonly query: z.ZodObject<{
+      limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+  };
+  /** How one went: done, or an error to try it again. */
+  readonly inboxAck: {
+    readonly method: 'POST';
+    readonly path: '/inbox/:key/:id/ack';
+    readonly body: z.ZodObject<{
+      lease: z.ZodString;
+      error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  };
+  /** A platform's write, as its platform author: `sync` where it lands. */
+  readonly syncImport: {
+    readonly method: 'POST';
+    readonly path: '/sync/imports';
+    readonly body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+      from: z.ZodNullable<z.ZodString>;
+      op: z.ZodLiteral<"post">;
+      origin: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        channel: z.ZodOptional<z.ZodString>;
+        thread: z.ZodString;
+        subthread: z.ZodNullable<z.ZodString>;
+        message: z.ZodString;
+        context: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>>;
+      source: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        channel: z.ZodString;
+        thread: z.ZodString;
+      }, z.core.$strip>>;
+      channel: z.ZodOptional<z.ZodString>;
+      re: z.ZodOptional<z.ZodString>;
+      text: z.ZodDefault<z.ZodString>;
+      labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      noSync: z.ZodOptional<z.ZodBoolean>;
+      attachments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        snapshot: z.ZodNullable<z.ZodObject<{
+          author: z.ZodString;
+          text: z.ZodString;
+          createdAt: z.ZodNullable<z.ZodString>;
+          files: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodNullable<z.ZodString>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        unavailable: z.ZodNullable<z.ZodString>;
+        message: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>>;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+      from: z.ZodNullable<z.ZodString>;
+      origin: z.ZodOptional<z.ZodObject<{
+        thread: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      message: z.ZodOptional<z.ZodString>;
+      op: z.ZodLiteral<"edit">;
+      text: z.ZodString;
+      source: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        channel: z.ZodString;
+        thread: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+      from: z.ZodNullable<z.ZodString>;
+      origin: z.ZodOptional<z.ZodObject<{
+        thread: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      message: z.ZodOptional<z.ZodString>;
+      op: z.ZodLiteral<"delete">;
+    }, z.core.$strip>, z.ZodObject<{
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+      from: z.ZodNullable<z.ZodString>;
+      origin: z.ZodOptional<z.ZodObject<{
+        thread: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      message: z.ZodOptional<z.ZodString>;
+      op: z.ZodLiteral<"react">;
+      emoji: z.ZodString;
+      remove: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+      from: z.ZodNullable<z.ZodString>;
+      origin: z.ZodOptional<z.ZodObject<{
+        thread: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      message: z.ZodOptional<z.ZodString>;
+      op: z.ZodLiteral<"labels">;
+      set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+      from: z.ZodNullable<z.ZodString>;
+      origin: z.ZodOptional<z.ZodObject<{
+        thread: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      message: z.ZodOptional<z.ZodString>;
+      op: z.ZodLiteral<"links">;
+      links: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        snapshot: z.ZodNullable<z.ZodObject<{
+          author: z.ZodString;
+          text: z.ZodString;
+          createdAt: z.ZodNullable<z.ZodString>;
+          files: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodNullable<z.ZodString>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        unavailable: z.ZodNullable<z.ZodString>;
+        message: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      op: z.ZodLiteral<"seen">;
+      author: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+    }, z.core.$strip>], "op">;
+  };
+  /** What sync did on a platform: a delivery, its files, a failure, or a thread's new target. */
+  readonly syncReceipt: {
+    readonly method: 'POST';
+    readonly path: '/sync/receipts';
+    readonly body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"message">;
+      message: z.ZodString;
+      target: z.ZodString;
+      external: z.ZodObject<{
+        thread: z.ZodString;
+        message: z.ZodString;
+        asUser: z.ZodOptional<z.ZodLiteral<true>>;
+      }, z.core.$strip>;
+      files: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"files">;
+      message: z.ZodString;
+      target: z.ZodString;
+      files: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"failed">;
+      message: z.ZodString;
+      target: z.ZodString;
+      error: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"thread">;
+      message: z.ZodString;
+      target: z.ZodString;
+      targetKind: z.ZodEnum<{
+        channel: "channel";
+        thread: "thread";
+      }>;
+      cause: z.ZodEnum<{
+        config: "config";
+        request: "request";
+      }>;
+    }, z.core.$strip>], "kind">;
+  };
+  /** A board thread's sync, by its key. */
+  readonly syncThread: {
+    readonly method: 'GET';
+    readonly path: '/sync/threads/:thread';
+  };
+  /** What platform IDs are on the board. */
+  readonly syncFind: {
+    readonly method: 'GET';
+    readonly path: '/sync/find';
+    readonly query: z.ZodObject<{
+      code: z.ZodOptional<z.ZodString>;
+      post: z.ZodOptional<z.ZodString>;
+      thread: z.ZodOptional<z.ZodString>;
+      message: z.ZodOptional<z.ZodString>;
+      account: z.ZodOptional<z.ZodString>;
+      person: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  };
+  /** Messages' copies on platforms. */
+  readonly syncCopies: {
+    readonly method: 'GET';
+    readonly path: '/sync/copies';
+    readonly query: z.ZodObject<{
+      message: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+  };
+  /** A person's recent roots, for telling their own platform copies from new messages. */
+  readonly syncRoots: {
+    readonly method: 'GET';
+    readonly path: '/sync/roots';
+    readonly query: z.ZodObject<{
+      by: z.ZodString;
+      since: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+  };
+  /** A one-time code for linking a platform account. */
+  readonly syncCode: {
+    readonly method: 'POST';
+    readonly path: '/sync/codes';
+    readonly body: z.ZodObject<{
+      sync: z.ZodString;
+    }, z.core.$strip>;
+  };
+  /** Links a platform account, by a code or for a person. */
+  readonly syncAccount: {
+    readonly method: 'POST';
+    readonly path: '/sync/accounts';
+    readonly body: z.ZodObject<{
+      sync: z.ZodString;
+      account: z.ZodObject<{
+        id: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodString;
+        isBot: z.ZodBoolean;
+        avatar: z.ZodPipe<z.ZodNullable<z.ZodString>, z.ZodTransform<string | null, string | null>>;
+      }, z.core.$strip>;
+      code: z.ZodString;
+      message: z.ZodOptional<z.ZodString>;
+      method: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        consent: "consent";
+      }>>;
+    }, z.core.$strip>;
+  };
+  /** Unlinks a platform account. */
+  readonly syncUnlink: {
+    readonly method: 'POST';
+    readonly path: '/sync/accounts/unlink';
+    readonly body: z.ZodObject<{
+      account: z.ZodString;
+    }, z.core.$strip>;
+  };
+  /** Reads a platform channel or thread on demand, where that sync runs, without syncing or storing it. Full access only. */
+  readonly readSource: {
+    readonly method: 'GET';
+    readonly path: '/sources/:key/read';
+    readonly query: z.ZodObject<{
+      target: z.ZodString;
+      limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+  };
+  readonly webhook: {
+    readonly method: 'POST';
+    readonly path: '/webhooks/:key';
+  };
+  readonly events: {
+    readonly method: 'GET';
+    readonly path: '/events';
+    readonly query: z.ZodObject<{
+      channel: z.ZodOptional<z.ZodString>;
+      re: z.ZodOptional<z.ZodString>;
+      by: z.ZodOptional<z.ZodString>;
+      mentions: z.ZodOptional<z.ZodString>;
+      label: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<readonly [string, null] | readonly [string, string[]], string>>>>>;
+      from: z.ZodOptional<z.ZodString>;
+      text: z.ZodOptional<z.ZodString>;
+      after: z.ZodOptional<z.ZodString>;
+      wait: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+      all: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    }, z.core.$strip>;
+  };
+  readonly avatar: {
+    readonly method: 'GET';
+    readonly path: '/avatars/:name';
+  };
+  /** The file is the body; `content-type` is its type and `x-board-filename` its name, URI-encoded. */
+  readonly upload: {
+    readonly method: 'POST';
+    readonly path: '/attachments';
+  };
+  readonly attachment: {
+    readonly method: 'GET';
+    readonly path: '/attachments/:id';
+  };
+  /** A file too big for one request: the board answers where to `PUT` it in its blob store. Needs a store with `uploadUrl`. */
+  readonly uploadStart: {
+    readonly method: 'POST';
+    readonly path: '/attachments/uploads';
+    readonly body: z.ZodObject<{
+      name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      size: z.ZodNumber;
+    }, z.core.$strip>;
+  };
+  /** After the `PUT`: the board checks what landed in the store and records the attachment. */
+  readonly uploadFinish: {
+    readonly method: 'POST';
+    readonly path: '/attachments/uploads/:id';
+  };
+  readonly openapi: {
+    readonly method: 'GET';
+    readonly path: '/openapi.json';
+  };
+  /** Your linked platform accounts. */
+  readonly identity: {
+    readonly method: 'GET';
+    readonly path: '/identity';
+  };
+  /** Starts a sign-in that carries a code (no token), on the board that runs the entry's sync. */
+  readonly signIn: {
+    readonly method: 'GET';
+    readonly path: '/identity/sign-in';
+    readonly query: z.ZodObject<{
+      sync: z.ZodString;
+      code: z.ZodString;
+    }, z.core.$strip>;
+  };
+  /** Where a sign-in comes back (no token): links the account it authorized to the code's person. */
+  readonly signedIn: {
+    readonly method: 'GET';
+    readonly path: '/identity/signed-in';
+    readonly query: z.ZodObject<{
+      sync: z.ZodString;
+      code: z.ZodString;
+    }, z.core.$strip>;
+  };
+  readonly identityUnlink: {
+    readonly method: 'POST';
+    readonly path: '/identity/unlink';
+    readonly body: z.ZodObject<{
+      actor: z.ZodString;
+    }, z.core.$strip>;
+  };
+  /** Watchers registered by boards on `http()`: every one to `manage` everywhere, the caller's own to anyone else. */
+  readonly watchers: {
+    readonly method: 'GET';
+    readonly path: '/watchers';
+  };
+  /** Registers the caller's watchers, replacing its last registration. On a board on `http()`, registers its own, with no body or token. */
+  readonly register: {
+    readonly method: 'POST';
+    readonly path: '/watchers';
+    readonly body: z.ZodObject<{
+      url: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+      watch: z.ZodRecord<z.ZodString, z.ZodObject<{
+        tail: z.ZodString;
+        when: z.ZodDefault<z.ZodEnum<{
+          enters: "enters";
+          matches: "matches";
+        }>>;
+      }, z.core.$strip>>;
+      sync: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        platform: z.ZodString;
+        signIn: z.ZodDefault<z.ZodBoolean>;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>;
+  };
+  /** The caller's matches it can run now, each leased to it until it acks. */
+  readonly matches: {
+    readonly method: 'GET';
+    readonly path: '/watchers/matches';
+    readonly query: z.ZodObject<{
+      limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+      wait: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+  };
+  readonly ack: {
+    readonly method: 'POST';
+    readonly path: '/watchers/matches/:id/ack';
+    readonly body: z.ZodObject<{
+      lease: z.ZodString;
+      error: z.ZodOptional<z.ZodString>;
+      skip: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+  };
+  /** On a board on `http()`: something matched. No body, no token: the board pulls what. */
+  readonly wake: {
+    readonly method: 'POST';
+    readonly path: '/wake';
+  };
+};
+type RouteName = keyof typeof routes;
+//#endregion
+//#region src/client/client.d.ts
+declare class BoardError extends Error {
+  readonly code: string;
+  readonly status: number;
+  constructor(code: string, message: string, status: number);
+}
+type Resolvable<T> = T | (() => T | Promise<T>);
+/** A profile name, `{ name, avatar }`, or null for no profile. */
+type ProfileOption = string | {
+  name: string;
+  avatar?: string;
+} | null;
+type ClientOptions = {
+  /** The board's URL, e.g. `https://www.example.com/api/board`. */
+  url: string;
+  /** An OIDC token whose audience is the board's URL, or a function returning one. Without one, `fetch` brings the credentials. */
+  token?: Resolvable<string>;
+  profile?: Resolvable<ProfileOption>;
+  /** Runtime session, recorded on writes and used to scope read cursors. */
+  session?: Resolvable<string | null>;
+  /** A person's handle; the board falls back to one derived from their user ID. */
+  handle?: Resolvable<string | null>;
+  /** Your display name and avatar, shown when you write as yourself (not as a profile). */
+  person?: Resolvable<{
+    name?: string | null;
+    avatar?: string | null;
+  } | null>;
+  /** Extra headers on every request. */
+  headers?: Resolvable<Record<string, string>>;
+  fetch?: typeof fetch;
+  /**
+   * How a direct upload's bytes go to the blob store's signed URL: `fetch` by default, never the
+   * board's own, which brings the board's credentials and would hand them to the store.
+   */
+  storeFetch?: typeof fetch;
+};
+type PostOptions = {
+  text: string;
+  labels?: Record<string, string>;
+  /** Keep this message on the board: no configured sync targets. */
+  noSync?: boolean;
+  /** External targets the new thread starts with: `slack:#incidents` starts one, `github:owner/repo:12` joins one. */
+  sync?: string[];
+  /** Makes retries idempotent: the same id never posts twice. */
+  id?: string;
+  /** Files from `upload`, or their IDs. */
+  attachments?: (Attachment | string)[];
+};
+type ReplyOptions = Omit<PostOptions, 'sync'>;
+/**
+ * When a scheduled message goes out: once `in` a while or `at` a time, or
+ * `every` so often (first at `at`, `in`, or one `every` from now), stopping
+ * `until` a time, `for` a while after the first send, or after `times` sends.
+ * A repeat with no stop runs until it's canceled.
+ */
+type ScheduleTiming = {
+  in?: string;
+  at?: Date | string;
+  every?: string;
+  until?: Date | string;
+  for?: string;
+  times?: number;
+};
+type ScheduleOptions = Omit<PostOptions, 'sync' | 'id'> & ScheduleTiming;
+/** What `upload` takes: the bytes, and what to call them. */
+type UploadInput = {
+  data: Blob | Uint8Array<ArrayBuffer>;
+  name: string;
+  /** A MIME type; a `Blob`'s own type, or one from the name's extension, otherwise. */
+  type?: string;
+};
+type WaitOptions = {
+  /** `'30s'`, `'10m'`, `'1h'`, or milliseconds. Default `'30m'`. */
+  timeout?: string | number;
+  signal?: AbortSignal;
+};
+declare function duration(value: string | number): number;
+type Filters = Omit<FiltersInput, 'label'> & {
+  /** `{ status: 'open' }` or `['status=open']`. */
+  label?: Record<string, string> | string[];
+};
+type BoardClient = ReturnType<typeof createBoardClient>;
+/** What a write returns, with the handles in it that matched nobody and stayed plain text. */
+type Written<T> = T & {
+  unknownMentions?: string[];
+};
+declare function createBoardClient(options: ClientOptions): {
+  url: string;
+  /**
+   * The board's HTTP API with this client's credentials, and the response as
+   * the board sent it, errors included: for proxies like `vb inspect`.
+   */
+  request: (path: string, init?: {
+    method?: string;
+    body?: Uint8Array<ArrayBuffer>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    /** Act as this profile (`null` for yourself) instead of the client's. */
+    as?: ProfileOption;
+  }) => Promise<Response>;
+  discovery: () => Promise<Discovery>;
+  me: () => Promise<Me>;
+  channels: () => Promise<Channel[]>;
+  actors: () => Promise<(Actor & {
+    person?: ActorView['person'];
+  })[]>;
+  /** Your linked platform accounts, and the sync entries you haven't linked (`unlinked`). */
+  identity: () => Promise<IdentityView>;
+  /** Unlinks one of your accounts, by actor ID or handle. History keeps its messages as they were. */
+  unlinkAccount: (account: string) => Promise<{
+    ok: true;
+    actor: string;
+  }>;
+  messages: (query?: Filters & Omit<MessagesQueryInput, keyof FiltersInput>) => Promise<MessagesPage>;
+  thread: (id: string) => Promise<ThreadView>;
+  /** Your own post with the client ID you gave it, as posting it answered: 404 `post_not_found` when there's none. */
+  posted: (id: string) => Promise<MessageView>;
+  /** Threads with a matching message, one summary each (root, reply count, latest reply), by latest activity. `limit` counts threads. */
+  threads: (query?: Filters & Omit<ThreadsQueryInput, keyof FiltersInput>) => Promise<ThreadsPage>;
+  /** `unknownMentions` lists the handles that matched nobody: they posted as plain text. */
+  post(channel: string, input: string | PostOptions): Promise<Written<MessageView>>;
+  reply(id: string, input: string | ReplyOptions): Promise<Written<MessageView>>;
+  /**
+   * Posts later, as you: a new thread when `target` is a channel, a reply when it's
+   * `{ re }`, any message's ID in the thread. Each message it posts carries
+   * `schedule: { id, n }`. Needs a board with a scheduler.
+   */
+  schedule(target: string | {
+    re: string;
+  }, input: ScheduleOptions): Promise<Written<ScheduleView>>;
+  /** Pending schedules (`all` for done and canceled too), oldest first. `re` is any message in a thread. */
+  schedules: (query?: SchedulesQueryInput) => Promise<ScheduleView[]>;
+  /** Stops a schedule: yours, or any with manage in its channel. `canceled` is false when it was already done or canceled. */
+  cancelSchedule: (id: string) => Promise<{
+    schedule: ScheduleView;
+    canceled: boolean;
+  }>;
+  /**
+   * Stores a file on the board, for a post or reply's `attachments`. Up to 4 MB goes in one
+   * request; bigger, up to 100 MB, goes straight to the board's blob store on a URL the board
+   * signs, where its store can (`no_direct_uploads` where it can't).
+   */
+  upload(input: UploadInput): Promise<Attachment>;
+  /** An attachment's bytes, as the board serves them: `content-type` is the file's type. */
+  download: (id: string, opts?: {
+    signal?: AbortSignal;
+  }) => Promise<Response>;
+  edit: (id: string, text: string) => Promise<{
+    ok: true;
+    unknownMentions?: string[];
+  }>;
+  delete: (id: string) => Promise<{
+    ok: true;
+  }>;
+  /** `emoji` is a short name, `:name:`, or the character itself. */
+  react: (id: string, emoji: string, opts?: {
+    remove?: boolean;
+  }) => Promise<{
+    ok: true;
+  }>;
+  label: (id: string, change: {
+    set?: Record<string, string>;
+    unset?: string[];
+  }) => Promise<{
+    ok: true;
+  }>;
+  /**
+   * Shows typing in the platform threads the message's thread is synced to
+   * (on WhatsApp, also marking the latest inbound message read). Ephemeral:
+   * nothing goes in the log. Answers the external threads that took it.
+   * `status` replaces "Typing…" on Slack ("running tests…").
+   */
+  typing: (id: string, status?: string) => Promise<string[]>;
+  /** Attaches the message's thread to an external target, backfilling it. Attaching twice is a no-op. */
+  sync: (id: string, target: string) => Promise<{
+    target: string;
+    attached: boolean;
+  }>;
+  /** Raw platform events for a sync entry, newest first. */
+  inbox: (key: string, opts?: {
+    channel?: string;
+    limit?: number;
+  }) => Promise<InboxEntry[]>;
+  /** Registers the caller's watchers, replacing its last registration: what a board on `http()` does. */
+  register: (input: {
+    url?: string | null;
+    watch: Record<string, {
+      tail: string;
+      when?: 'matches' | 'enters';
+    }>;
+    sync?: {
+      key: string;
+      platform: string;
+      signIn?: boolean;
+    }[];
+  }) => Promise<RegistrationView>;
+  /** Registered watchers: every one to `manage` everywhere, the caller's own to anyone else. */
+  watchers: () => Promise<RegistrationView[]>;
+  /** The caller's matches it can run now, each leased to it until it acks. `wait` holds the request up to that many seconds for one. */
+  matches: (opts?: {
+    limit?: number;
+    wait?: number;
+    signal?: AbortSignal;
+  }) => Promise<MatchView[]>;
+  /** How a pulled match went: done, an error to try again, or `skip` to drop it. */
+  ack: (id: string, body: {
+    lease: string;
+    error?: string;
+    skip?: boolean;
+  }) => Promise<{
+    ok: true;
+  }>;
+  /**
+   * Reads a platform channel (`#name`, an ID), thread (`C0123:1727000000.123456`),
+   * or message permalink on demand, without syncing or storing it. Full access only.
+   */
+  readSource: (key: string, target: string, opts?: {
+    limit?: number;
+  }) => Promise<SourceRead>;
+  poll: (query?: Filters & {
+    after?: string;
+    wait?: number;
+    all?: boolean;
+  }, signal?: AbortSignal) => Promise<EventsPage>;
+  /** A platform's write, as its platform author: idempotent per platform event for a post, found from its origin otherwise. */
+  syncImport: (body: SyncImportInput) => Promise<{
+    message: string | null;
+    dropped?: string[];
+  }>;
+  /** What sync did on a platform: a delivery, its files, a failure, or a thread's new target. */
+  syncReceipt: (body: SyncReceiptInput) => Promise<{
+    ok: true;
+    attached?: boolean;
+  }>;
+  /** A board thread's sync, by its key. */
+  syncThread: (thread: string) => Promise<SyncThreadView>;
+  /** What platform IDs are on the board: a thread, a message, who an account is, a person's accounts. */
+  syncFind: (query: SyncFindInput, opts?: {
+    signal?: AbortSignal;
+  }) => Promise<SyncFindView>;
+  /** Messages' copies on platforms, by message and target. */
+  syncCopies: (messages: string[]) => Promise<Record<string, Record<string, ExternalCopy>>>;
+  /** A person's roots since `since`. */
+  syncRoots: (by: string, since: Date | number) => Promise<MessageView[]>;
+  /** Pushes platform events into your inbox for sync key `key`; each platform ID lands once. */
+  inboxPush: (key: string, events: {
+    id: string;
+    event: InboxItem['event'];
+    raw: unknown;
+  }[]) => Promise<{
+    ok: true;
+  }>;
+  /** Your next inbox events for `key`, leased to you until you ack them, one platform thread at a time. */
+  inboxNext: (key: string, opts?: {
+    limit?: number;
+  }) => Promise<InboxItem[]>;
+  /** How an inbox event went: done, or an error to try it again. */
+  inboxAck: (key: string, id: string, body: {
+    lease: string;
+    error?: string;
+  }) => Promise<{
+    ok: true;
+  }>;
+  /**
+   * A one-time code for linking your account on sync entry `sync`, to post from that account where
+   * the board syncs, and `signIn` when the entry signs people in: open it (only you) and approve.
+   * Only people get one, each for themselves. `identity()` shows the link once it's made.
+   */
+  syncCode: (sync: string) => Promise<SyncCodeView>;
+  /** Links a platform account to whoever a code was issued to: one posted from it, or carried through its sign-in. */
+  syncAccount: (body: SyncAccountInput) => Promise<{
+    person: string;
+    link: LinkedAccount;
+  }>;
+  /** Unlinks a platform account: your own, or anyone's with `sync`. */
+  syncUnlink: (account: string) => Promise<{
+    ok: true;
+  }>;
+  /** Live events. Reconnects from the last seen index whenever the stream closes. */
+  events(query?: Filters & Pick<EventsQueryInput, 'after' | 'all'>, opts?: {
+    signal?: AbortSignal;
+  }): AsyncGenerator<BoardEventView>;
+  /** The next matching event after `after` (default: now), or null on timeout. */
+  wait(query?: Filters & {
+    after?: string;
+  }, opts?: WaitOptions): Promise<BoardEventView | null>;
+};
+//#endregion
+//#region src/sync/events.d.ts
+declare const EventBase: z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  id: z.ZodString;
+  platform: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+}, z.core.$strip>;
+type EventBase<P extends string = string> = Omit<z.infer<typeof EventBase>, 'platform'> & {
+  platform: P;
+};
+type ProviderEvent = EventBase & ExternalEvent & {
+  type: string;
+};
+declare function envelope(platform: string, key: string, event: ExternalEvent, raw: unknown, id: string): {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "message";
+  message: string;
+  isRoot: boolean;
+  text: string;
+  context: string | null;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  files?: {
+    type: "audio" | "file" | "image" | "video";
+    name?: string | undefined;
+    mimeType?: string | undefined;
+    size?: number | undefined;
+    url?: string | undefined;
+    fetchMetadata?: Record<string, string> | undefined;
+  }[] | undefined;
+  links?: {
+    url: string;
+    thread: string;
+    message: string;
+    snapshot: {
+      author: string;
+      text: string;
+      createdAt: string | null;
+      files: {
+        name: string;
+        url: string | null;
+      }[];
+    } | null;
+  }[] | undefined;
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "edited";
+  message: string;
+  text: string;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  links?: {
+    url: string;
+    thread: string;
+    message: string;
+    snapshot: {
+      author: string;
+      text: string;
+      createdAt: string | null;
+      files: {
+        name: string;
+        url: string | null;
+      }[];
+    } | null;
+  }[] | undefined;
+  linksOnly?: boolean | undefined;
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "deleted";
+  message: string;
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "reaction";
+  message: string;
+  emoji: string;
+  added: boolean;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "lifecycle";
+  title: string;
+  url: string | null;
+  labels: Record<string, string>;
+  unset: string[];
+  owns?: string[] | undefined;
+  reply: string | null;
+  createRoot: boolean;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+};
+declare function eventSchema<P extends string, M extends string>(platform: P, messageType: M): z.ZodDiscriminatedUnion<[z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"message">;
+  message: z.ZodString;
+  isRoot: z.ZodBoolean;
+  text: z.ZodString;
+  context: z.ZodNullable<z.ZodString>;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<{
+      audio: "audio";
+      file: "file";
+      image: "image";
+      video: "video";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+    fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    url: z.ZodString;
+    thread: z.ZodString;
+    message: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodObject<{
+      author: z.ZodString;
+      text: z.ZodString;
+      createdAt: z.ZodNullable<z.ZodString>;
+      files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<P>;
+  type: z.ZodLiteral<M>;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"edited">;
+  message: z.ZodString;
+  text: z.ZodString;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    url: z.ZodString;
+    thread: z.ZodString;
+    message: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodObject<{
+      author: z.ZodString;
+      text: z.ZodString;
+      createdAt: z.ZodNullable<z.ZodString>;
+      files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+  linksOnly: z.ZodOptional<z.ZodBoolean>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<P>;
+  type: z.ZodLiteral<"message.edited">;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"deleted">;
+  message: z.ZodString;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<P>;
+  type: z.ZodLiteral<"message.deleted">;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"reaction">;
+  message: z.ZodString;
+  emoji: z.ZodString;
+  added: z.ZodBoolean;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<P>;
+  type: z.ZodEnum<{
+    "reaction.added": "reaction.added";
+    "reaction.removed": "reaction.removed";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"lifecycle">;
+  type: z.ZodString;
+  title: z.ZodString;
+  url: z.ZodNullable<z.ZodString>;
+  labels: z.ZodRecord<z.ZodString, z.ZodString>;
+  unset: z.ZodArray<z.ZodString>;
+  owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  reply: z.ZodNullable<z.ZodString>;
+  createRoot: z.ZodBoolean;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<P>;
+}, z.core.$strip>], "kind">;
+type SyncRoot = {
+  text: string;
+  labels: Record<string, string>;
+  author: ExternalAuthor;
+  raw: unknown;
+};
+type RootOverride = (root: Readonly<SyncRoot>) => {
+  text?: string;
+  labels?: Record<string, string>;
+};
+declare const SyncOverrides: z.ZodObject<{
+  root: z.ZodOptional<z.ZodCustom<RootOverride, RootOverride>>;
+  text: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  noSync: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type SyncOverrides = z.infer<typeof SyncOverrides>;
+/** What an import made: its thread's root and the message, as IDs clients pass back as they got them. */
+type SyncResult = {
+  root: string | null;
+  message: string | null;
+};
+//#endregion
+//#region src/sync/users.d.ts
+/**
+ * People's own platform tokens, so a board message they wrote reaches Slack or
+ * GitHub as them, and signing in proves an account is theirs. The board never
+ * stores a token: it asks for one at each delivery, and a person without one
+ * (never signed in, revoked, expired) is delivered as the bot, as before.
+ */
+type UserTokens = {
+  /**
+   * A sign-in URL that binds whoever completes it to `principal`. Show it only to them. With
+   * `callback`, the platform sends them there once they've approved.
+   */
+  authorize(principal: string, options?: {
+    callback?: string;
+  }): Promise<string>;
+  /** `principal`'s token on the platform, or null when they haven't signed in. */
+  token(principal: string): Promise<string | null>;
+};
+/**
+ * Gives an adapter people's tokens, for your own OAuth: `slack({ adapter:
+ * withUserTokens(createSlackAdapter(...), { authorize, token }) })`. A Connect
+ * connector name (`adapter: 'slack/acme'`) does this for you.
+ */
+declare function withUserTokens<A extends object>(adapter: A, tokens: UserTokens): A;
+/** Vercel Connect's user tokens for `connector`: the subject is the board's principal, so Connect binds the account to it. */
+declare function connectUserTokens(connector: string): UserTokens;
+//#endregion
+//#region src/sync/provider.d.ts
+declare const ResolvedTarget: z.ZodObject<{
+  target: z.ZodString;
+  channel: z.ZodString;
+  kind: z.ZodEnum<{
+    channel: "channel";
+    thread: "thread";
+  }>;
+}, z.core.$strict>;
+type ResolvedTarget = z.infer<typeof ResolvedTarget>;
+type SyncClient<E extends ProviderEvent = ProviderEvent> = Omit<BoardClient, 'sync'> & {
+  sync(id: string, target: string): ReturnType<BoardClient['sync']>;
+  sync(channel: string, event: E, overrides?: SyncOverrides): Promise<SyncResult>;
+};
+type SyncHandler<E extends ProviderEvent> = (args: {
+  event: E;
+  board: SyncClient<E>;
+  /**
+   * The platform's own link to the event's message (Slack's `chat.getPermalink`), fetched on
+   * the first call and kept for the rest of the callback. Null when the event has no single
+   * message or the platform has no links. It only reads the URL: nothing is synced or joined.
+   */
+  permalink(): Promise<string | null>;
+}) => unknown;
+type SyncContext = {
+  id: string;
+  key: string;
+  event: ExternalEvent;
+  raw: unknown;
+  board: BoardClient;
+  client<E extends ProviderEvent>(event: E): SyncClient<E>;
+  apply(channel: string, overrides?: SyncOverrides): Promise<SyncResult>;
+};
+type ProviderMapping = {
+  channel?: string;
+  run?: (context: SyncContext) => unknown;
+};
+type RenderInput = {
+  /** The message as clients see it: its IDs are refs. */
+  message: Readonly<MessageView>;
+  author: Readonly<Actor> | null;
+  /** How this platform mentions an actor, through linked accounts; null when it can't. */
+  mentionOf: (actor: string) => string | null;
+  label: string;
+  target: string;
+};
+type EventMapping<E extends ProviderEvent> = string | SyncHandler<E> | {
+  channel: string;
+  run: SyncHandler<E>;
+};
+type FileDelivery = {
+  message: string;
+  files: string[];
+};
+/** What a linked message said, or why the platform wouldn't say. */
+type FetchedLink = Pick<Link, 'snapshot' | 'unavailable'>;
+/** A file to send: its bytes (a Node `Buffer` is one), its name, and its type. */
+type ProviderFile = {
+  data: Uint8Array;
+  filename: string;
+  mimeType?: string;
+};
+/**
+ * Who a post is from, for a platform that can show it as the sender (Slack's per-message
+ * username and icon): `name` is the label the text opens with (`**name**: …`).
+ */
+type ProviderSender = {
+  name: string;
+  avatar: string | null;
+};
+type ProviderPost = {
+  markdown: string;
+  files?: ProviderFile[];
+  as?: ProviderSender;
+};
+type ProviderDelivery = {
+  thread: string;
+  message: string;
+  files?: string[];
+};
+type ProviderOptions = {
+  platform: string;
+  canStartThreads?: boolean;
+  singleReaction?: boolean;
+  uploadsFiles?: boolean;
+  render?: (input: RenderInput) => string;
+  /** People's own tokens, to post as them and to link accounts by signing in. */
+  users?: UserTokens | null;
+};
+declare const ReceivedEvent: z.ZodObject<{
+  event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    channel: z.ZodString;
+    thread: z.ZodString;
+    subthread: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"message">;
+    message: z.ZodString;
+    isRoot: z.ZodBoolean;
+    text: z.ZodString;
+    context: z.ZodNullable<z.ZodString>;
+    author: z.ZodObject<{
+      id: z.ZodString;
+      handle: z.ZodString;
+      name: z.ZodString;
+      avatar: z.ZodNullable<z.ZodString>;
+      isBot: z.ZodBoolean;
+    }, z.core.$strip>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      type: z.ZodEnum<{
+        audio: "audio";
+        file: "file";
+        image: "image";
+        video: "video";
+      }>;
+      name: z.ZodOptional<z.ZodString>;
+      mimeType: z.ZodOptional<z.ZodString>;
+      size: z.ZodOptional<z.ZodNumber>;
+      url: z.ZodOptional<z.ZodString>;
+      fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      url: z.ZodString;
+      thread: z.ZodString;
+      message: z.ZodString;
+      snapshot: z.ZodNullable<z.ZodObject<{
+        author: z.ZodString;
+        text: z.ZodString;
+        createdAt: z.ZodNullable<z.ZodString>;
+        files: z.ZodArray<z.ZodObject<{
+          name: z.ZodString;
+          url: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>, z.ZodObject<{
+    channel: z.ZodString;
+    thread: z.ZodString;
+    subthread: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"edited">;
+    message: z.ZodString;
+    text: z.ZodString;
+    author: z.ZodObject<{
+      id: z.ZodString;
+      handle: z.ZodString;
+      name: z.ZodString;
+      avatar: z.ZodNullable<z.ZodString>;
+      isBot: z.ZodBoolean;
+    }, z.core.$strip>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      url: z.ZodString;
+      thread: z.ZodString;
+      message: z.ZodString;
+      snapshot: z.ZodNullable<z.ZodObject<{
+        author: z.ZodString;
+        text: z.ZodString;
+        createdAt: z.ZodNullable<z.ZodString>;
+        files: z.ZodArray<z.ZodObject<{
+          name: z.ZodString;
+          url: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    linksOnly: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>, z.ZodObject<{
+    channel: z.ZodString;
+    thread: z.ZodString;
+    subthread: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"deleted">;
+    message: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    channel: z.ZodString;
+    thread: z.ZodString;
+    subthread: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"reaction">;
+    message: z.ZodString;
+    emoji: z.ZodString;
+    added: z.ZodBoolean;
+    author: z.ZodObject<{
+      id: z.ZodString;
+      handle: z.ZodString;
+      name: z.ZodString;
+      avatar: z.ZodNullable<z.ZodString>;
+      isBot: z.ZodBoolean;
+    }, z.core.$strip>;
+  }, z.core.$strip>, z.ZodObject<{
+    channel: z.ZodString;
+    thread: z.ZodString;
+    kind: z.ZodLiteral<"lifecycle">;
+    type: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    labels: z.ZodRecord<z.ZodString, z.ZodString>;
+    unset: z.ZodArray<z.ZodString>;
+    owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    reply: z.ZodNullable<z.ZodString>;
+    createRoot: z.ZodBoolean;
+    author: z.ZodObject<{
+      id: z.ZodString;
+      handle: z.ZodString;
+      name: z.ZodString;
+      avatar: z.ZodNullable<z.ZodString>;
+      isBot: z.ZodBoolean;
+    }, z.core.$strip>;
+  }, z.core.$strip>], "kind">;
+  raw: z.ZodUnknown;
+  dedupe: z.ZodString;
+}, z.core.$strip>;
+type ReceivedEvent = z.infer<typeof ReceivedEvent>;
+type Receive = (received: ReceivedEvent) => Promise<void>;
+declare abstract class SyncProvider<E extends ProviderEvent = ProviderEvent> {
+  readonly platform: string;
+  readonly canStartThreads: boolean;
+  readonly singleReaction: boolean;
+  readonly uploadsFiles: boolean;
+  readonly mappings: Record<string, ProviderMapping>;
+  /** People's tokens, when the adapter has them: messages they write post as them. */
+  readonly users: UserTokens | null;
+  protected readonly options: ProviderOptions;
+  constructor(options: ProviderOptions);
+  abstract receive(key: string, request: Request, emit: Receive): Promise<Response>;
+  abstract resolveChannel(key: string): Promise<string>;
+  abstract resolveTarget(target: string): Promise<ResolvedTarget>;
+  abstract post(target: string, kind: ResolvedTarget['kind'], body: ProviderPost): Promise<ProviderDelivery>;
+  /** The platform account a person's token belongs to. */
+  whoAmI(_token: string): Promise<ExternalAuthor>;
+  /** `post`, as the person whose token this is. */
+  postAs(_token: string, _target: string, _kind: ResolvedTarget['kind'], _body: ProviderPost): Promise<ProviderDelivery>;
+  editAs(_token: string, _thread: string, _message: string, _body: ProviderPost): Promise<void>;
+  deleteAs(_token: string, _thread: string, _message: string): Promise<void>;
+  findByEmail(_email: string): Promise<ExternalAuthor | null>;
+  mention(_actor: Actor): string | null;
+  fetchRoot(_thread: string): Promise<SyncRoot | null>;
+  fetchFile(_file: ExternalFile): Promise<Uint8Array | null>;
+  /** The platform's own link to an event's message, or null when it has none. */
+  permalink(_event: E): Promise<string | null>;
+  /** A linked message the platform didn't describe, read from the platform. */
+  fetchLink(_link: ExternalLink): Promise<FetchedLink>;
+  /**
+   * A channel or thread, read on demand for whoever asked: nothing is synced,
+   * stored, or joined. Throws `UnreadableError` for what it won't read.
+   */
+  read(_target: string, _options: {
+    limit: number;
+  }): Promise<SourceRead>;
+  edit(_thread: string, _message: string, _body: ProviderPost): Promise<void>;
+  delete(_thread: string, _message: string): Promise<void>;
+  react(_thread: string, _message: string, _emoji: string, _added: boolean): Promise<void>;
+  startTyping(_thread: string, _latest: string | null, _status?: string): Promise<void>;
+  /**
+   * The channel whose inbox a thread's events land in (`slack:C0123ABC` for `slack:C0123ABC:1727.1234`),
+   * worked out without calling the platform. Null when the provider can't tell: a key's inbox then
+   * lists only the mapped channels'.
+   */
+  inboxChannel(_key: string, _thread: string): string | null;
+  deleteFiles(_ids: string[]): Promise<void>;
+  refusesFiles(_error: unknown): boolean;
+  uploadFiles(_thread: string, _files: ProviderFile[]): Promise<FileDelivery>;
+  abstract event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): E;
+  sync(context: SyncContext, channel: string, overrides?: SyncOverrides): Promise<SyncResult>;
+  render(input: RenderInput): string;
+  protected map(key: string, value: EventMapping<E>): void;
+}
+//#endregion
+export { InboxAckBody as $, ThreadSummaryView as $t, PostOptions as A, SchedulesQueryInput as At, ActorView as B, SyncCodeView as Bt, SyncResult as C, ResolvedSyncTarget as Ct, BoardClient as D, ScheduleInput as Dt, eventSchema as E, ScheduleBodyOutput as Et, UploadInput as F, SourceReadQuery as Ft, Discovery as G, SyncFindView as Gt, BoardEventView as H, SyncCopiesView as Ht, WaitOptions as I, SyncAccountBody as It, EventsQuery as J, SyncReceiptBody as Jt, EditBody as K, SyncImportBody as Kt, Written as L, SyncAccountInput as Lt, ReplyOptions as M, SignInQuery as Mt, ScheduleOptions as N, SourceMessage as Nt, BoardError as O, ScheduleView as Ot, ScheduleTiming as P, SourceRead as Pt, IdentityView as Q, SyncUnlinkBody as Qt, duration as R, SyncBody as Rt, SyncOverrides as S, RegistrationView as St, envelope as T, ScheduleBody as Tt, ChannelView as U, SyncFindInput as Ut, ApiError as V, SyncCopiesQuery as Vt, DeleteBody as W, SyncFindQuery as Wt, FiltersInput as X, SyncRootsQuery as Xt, EventsQueryInput as Y, SyncReceiptInput as Yt, IdentityUnlinkBody as Z, SyncThreadView as Zt, connectUserTokens as _, PostInput as _t, ProviderFile as a, TypingResult as an, LabelBody as at, ProviderEvent as b, Ref as bt, Receive as c, routes as cn, MatchView as ct, ResolvedTarget as d, MessageView as dt, ThreadView as en, InboxEntry as et, SyncClient as f, MessagesPage as ft, UserTokens as g, PostBody as gt, SyncProvider as h, PersonView as ht, ProviderDelivery as i, TypingBody as in, InboxQuery as it, ProfileOption as j, SchedulesQueryOutput as jt, Filters as k, SchedulesQuery as kt, ReceivedEvent as l, MatchesQuery as lt, SyncHandler as m, MessagesQueryInput as mt, FetchedLink as n, ThreadsQuery as nn, InboxNextQuery as nt, ProviderOptions as o, UploadStartBody as on, LinkView as ot, SyncContext as p, MessagesQuery as pt, EventsPage as q, SyncImportInput as qt, FileDelivery as r, ThreadsQueryInput as rn, InboxPushBody as rt, ProviderPost as s, UploadTicket as sn, LinkedAccount as st, EventMapping as t, ThreadsPage as tn, InboxItem as tt, RenderInput as u, Me as ut, withUserTokens as v, REGISTERED_WATCHERS_MAX as vt, SyncRoot as w, RouteName as wt, RootOverride as x, RegisterBody as xt, EventBase as y, ReactBody as yt, AckBody as z, SyncCodeBody as zt };