@vercel/board 0.0.0 → 0.16.0

package/dist/sync-kapso.d.mts

@@ -0,0 +1,175 @@
+import { m as SyncHandler, p as SyncContext, t as EventMapping, u as RenderInput } from "./provider-BGjz-mDa.mjs";
+import { n as ChatSyncProvider, t as ChatInput } from "./chat-provider-XCnQlxq6.mjs";
+import { z } from "zod";
+import { Adapter } from "chat";
+//#region src/sync/kapso.d.ts
+export declare const WhatsAppEvent: 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<"whatsapp">;
+  type: z.ZodLiteral<"message">;
+}, 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<"whatsapp">;
+  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<"whatsapp">;
+  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<"whatsapp">;
+  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<"whatsapp">;
+}, z.core.$strip>], "kind">;
+export type WhatsAppEvent = z.infer<typeof WhatsAppEvent>;
+type MarkRead = (input: {
+  phoneNumberId: string;
+  messageId: string;
+  typingIndicator: {
+    type: 'text';
+  };
+}) => Promise<unknown>;
+export type KapsoHandler = SyncHandler<WhatsAppEvent>;
+export type KapsoOptions = {
+  adapter: Adapter;
+  render?: (input: RenderInput) => string;
+  markRead: MarkRead;
+  numbers: Record<string, EventMapping<WhatsAppEvent>>;
+};
+/**
+ * Syncs WhatsApp numbers on Kapso with board channels. Keys are phone number
+ * IDs (`'16315558151'`); values are a board channel (a two-way mirror) or a
+ * callback that handles every incoming event. Each Kapso conversation is a
+ * thread. WhatsApp has no threads in a number, so a board thread never starts
+ * one: a board root in a mirrored channel stays on the board.
+ */
+export declare function kapso(options: KapsoOptions): KapsoProvider;
+export declare class KapsoProvider extends ChatSyncProvider<WhatsAppEvent> {
+  constructor(options: KapsoOptions);
+  eventId(key: string, input: ChatInput): string;
+  event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): WhatsAppEvent;
+}
+//#endregion

package/dist/sync-kapso.mjs

@@ -0,0 +1,86 @@
+import { c as eventSchema, s as envelope } from "./provider-CuewcDNZ.mjs";
+import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-jFSeyNmB.mjs";
+import { z } from "zod";
+//#region src/sync/kapso.ts
+const decode = (id) => id.split(":").map((part) => Buffer.from(part, "base64url").toString("utf8")).join(":");
+const encode = (id) => id.split(":").map((part) => Buffer.from(part, "utf8").toString("base64url")).join(":");
+const WhatsAppEvent = eventSchema("whatsapp", "message");
+/**
+* Syncs WhatsApp numbers on Kapso with board channels. Keys are phone number
+* IDs (`'16315558151'`); values are a board channel (a two-way mirror) or a
+* callback that handles every incoming event. Each Kapso conversation is a
+* thread. WhatsApp has no threads in a number, so a board thread never starts
+* one: a board root in a mirrored channel stays on the board.
+*/
+function kapso(options) {
+	return new KapsoProvider(options);
+}
+var KapsoProvider = class extends ChatSyncProvider {
+	constructor(options) {
+		if (typeof options.markRead !== "function") throw new Error("kapso requires a public markRead operation for cross-instance read and typing");
+		const fileIds = (raw) => (raw?.responses ?? []).flatMap((response) => response.messages?.[0]?.id ?? []);
+		super({
+			fileIds,
+			render: options.render,
+			platform: "whatsapp",
+			adapter: options.adapter,
+			canStartThreads: false,
+			async uploadFiles(thread, files) {
+				const sent = await options.adapter.postMessage(thread, {
+					markdown: "",
+					files
+				});
+				return {
+					message: sent.id,
+					files: fileIds(sent.raw)
+				};
+			},
+			refusesFiles: (error) => error?.code === "VALIDATION_ERROR",
+			async resolveChannel(key) {
+				if (!/^\d+$/.test(key)) throw new Error(`${key} isn't a phone number ID; use the number's ID from Kapso, not the number`);
+				return key;
+			},
+			fromChatId: decode,
+			toChatId: encode,
+			singleReaction: true,
+			async startTyping(thread, latest) {
+				if (!latest) return options.adapter.startTyping(thread);
+				const [phoneNumberId] = decode(thread.slice(thread.indexOf(":") + 1)).split(":");
+				await options.markRead({
+					phoneNumberId,
+					messageId: latest,
+					typingIndicator: { type: "text" }
+				});
+			},
+			groupThread: (thread) => thread,
+			isRoot: () => false,
+			context: () => null,
+			markdown(message) {
+				const text = markdownOf(message);
+				const transcript = message.raw?.kapso?.transcript?.text;
+				return [text, typeof transcript === "string" && transcript.trim() && transcript !== text ? `> ${transcript.trim()}` : null].filter(Boolean).join("\n\n");
+			},
+			async resolveTarget(target) {
+				const parts = target.split(":");
+				if (!/^\d+$/.test(parts[0]) || parts.length !== 1 && parts.length !== 3) throw new Error(`invalid Kapso target: ${target}`);
+				return {
+					target,
+					channel: parts[0],
+					kind: parts.length === 1 ? "channel" : "thread"
+				};
+			}
+		});
+		for (const [key, value] of Object.entries(options.numbers)) this.map(key, value);
+	}
+	eventId(key, input) {
+		if (input.kind !== "reaction") return super.eventId(key, input);
+		const reaction = input.reaction;
+		const stamp = z.looseObject({ id: z.string().min(1) }).parse(reaction.raw).id;
+		return `reaction:${key}:${this.toNative(reaction.threadId)}|${reaction.messageId}|${reaction.rawEmoji}|${reaction.user.userId}|${reaction.added}|${stamp}`;
+	}
+	event(context) {
+		return WhatsAppEvent.parse(envelope(this.platform, context.key, context.event, context.raw, context.id));
+	}
+};
+//#endregion
+export { KapsoProvider, WhatsAppEvent, kapso };

package/dist/sync-slack.d.mts

@@ -0,0 +1,364 @@
+import { v as ExternalLink } from "./reducers-B_vUGQRp.mjs";
+import { d as ResolvedTarget, g as UserTokens, i as ProviderDelivery, m as SyncHandler, p as SyncContext, s as ProviderPost, t as EventMapping, u as RenderInput, v as withUserTokens } from "./provider-BGjz-mDa.mjs";
+import { n as ChatSyncProvider, t as ChatInput } from "./chat-provider-XCnQlxq6.mjs";
+import { z } from "zod";
+import { Adapter } from "chat";
+//#region src/sync/slack.d.ts
+type SlackChannel = {
+  id?: string;
+  name?: string;
+  is_member?: boolean;
+  is_private?: boolean;
+  is_im?: boolean;
+  is_mpim?: boolean;
+  is_ext_shared?: boolean;
+};
+export type SlackClient = {
+  conversations: {
+    list(args: Record<string, unknown>): Promise<{
+      channels?: SlackChannel[];
+      response_metadata?: {
+        next_cursor?: string;
+      };
+    }>;
+    info(args: {
+      channel: string;
+    }): Promise<{
+      channel?: SlackChannel;
+    }>;
+    join(args: {
+      channel: string;
+    }): Promise<unknown>;
+    /** Reads a linked message or a thread; needs `channels:history` (`groups:history` for private channels). */
+    replies?(args: {
+      channel: string;
+      ts: string;
+      oldest?: string;
+      latest?: string;
+      inclusive?: boolean;
+      limit: number;
+    }): Promise<{
+      messages?: SlackMessage[];
+      has_more?: boolean;
+    }>;
+    /** Reads a channel, newest first, for `vb sources <key> read`; needs `channels:history`. */
+    history?(args: {
+      channel: string;
+      limit: number;
+    }): Promise<{
+      messages?: SlackMessage[];
+      has_more?: boolean;
+    }>;
+  };
+  users?: {
+    info(args: {
+      user: string;
+    }): Promise<{
+      user?: SlackUser;
+    }>;
+    lookupByEmail?(args: {
+      email: string;
+    }): Promise<{
+      user?: SlackUser;
+    }>;
+  };
+  files?: {
+    delete(args: {
+      file: string;
+    }): Promise<unknown>;
+  };
+  /** Posts an agent's message under its own name; needs `chat:write.customize` for `username` and `icon_url`. */
+  chat?: {
+    postMessage(args: SlackPost): Promise<{
+      ts?: string;
+    }>;
+    /** A message's link, with the workspace's own host and a reply's `thread_ts`. */
+    getPermalink?(args: {
+      channel: string;
+      message_ts: string;
+    }): Promise<{
+      permalink?: string;
+    }>;
+  };
+  /** Says which scopes the app has (`response_metadata.scopes`, from Slack's `x-oauth-scopes`). */
+  /** Also whose a token is (`user_id`), for a person's own. */
+  auth?: {
+    test(args?: Record<string, unknown>): Promise<{
+      user_id?: string;
+      user?: string;
+      response_metadata?: {
+        scopes?: string[];
+      };
+    }>;
+  };
+};
+type SlackPost = {
+  channel: string;
+  thread_ts?: string;
+  text?: string;
+  markdown_text?: string;
+  username?: string;
+  icon_url?: string;
+  unfurl_links?: boolean;
+  unfurl_media?: boolean;
+};
+/** The `**name**: ` a message's text opens with, taken out when Slack shows the name as the sender. */
+export declare function withoutLabel(markdown: string, name: string): string;
+/** GitHub's markdown allows inline HTML, which Slack shows as raw tags: as markdown instead, outside code. */
+export declare function withoutHtml(markdown: string): string;
+/**
+ * A sender's picture as Slack's `icon_url`: an https image. The board's built-in agent
+ * avatars are SVGs, which Slack won't show, so those keep the app's icon.
+ */
+export declare function slackIcon(avatar: string | null): string | null;
+type SlackUser = {
+  id?: string;
+  name?: string;
+  real_name?: string;
+  is_bot?: boolean;
+  profile?: {
+    display_name?: string;
+    real_name?: string;
+    image_72?: string;
+    image_48?: string;
+  };
+};
+type SlackFile = {
+  name?: string;
+  title?: string;
+  permalink?: string;
+};
+type SlackMessage = {
+  ts?: string;
+  text?: string;
+  user?: string;
+  username?: string;
+  bot_profile?: {
+    name?: string;
+  };
+  files?: SlackFile[];
+  thread_ts?: string;
+  reply_count?: number;
+};
+/** What Slack attaches to a message that links another: `is_msg_unfurl` marks a message link's. */
+type SlackAttachment = {
+  is_msg_unfurl?: boolean;
+  /** A forward's shared message. */
+  is_share?: boolean;
+  from_url?: string;
+  original_url?: string;
+  channel_id?: string;
+  ts?: string;
+  author_id?: string;
+  author_name?: string;
+  author_subname?: string;
+  text?: string;
+  files?: SlackFile[];
+};
+/**
+ * Every Slack message a message's mrkdwn links to, in order, with the unfurls Slack attached for them,
+ * then the messages it forwards: a forward's shared message is only in its `is_share` attachments.
+ */
+export declare function slackLinks(key: string, text: string, attachments?: SlackAttachment[], markdown?: (mrkdwn: string) => string): ExternalLink[];
+/**
+ * What a forward with no text of its own says: the messages it shares, quoted,
+ * so the board (and whoever watches it) reads what was forwarded, not "(no text)".
+ */
+export declare function forwardText(links: ExternalLink[]): string;
+/**
+ * The name a file goes to Slack under. Slack picks a file's type from its
+ * extension, so a text file named `run.log` arrives as a binary download;
+ * `run.log.txt` arrives as text it previews. The board keeps the file's own name.
+ */
+export declare function slackFileName(filename: string, mimeType?: string): string;
+export declare const SlackEvent: 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<"slack">;
+  type: z.ZodLiteral<"message">;
+}, 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<"slack">;
+  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<"slack">;
+  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<"slack">;
+  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<"slack">;
+}, z.core.$strip>], "kind">;
+export type SlackEvent = z.infer<typeof SlackEvent>;
+export type SlackHandler = SyncHandler<SlackEvent>;
+export type SlackOptions = {
+  /**
+   * A Vercel Connect connector (`'slack/acme'`): board builds the Slack adapter,
+   * its Web API client, and people's sign-in, so messages they write post as them.
+   * Or your own Chat SDK adapter, wrapped in `withUserTokens` to post as people.
+   */
+  adapter: Adapter | string;
+  render?: (input: RenderInput) => string;
+  /** Not needed with a connector. */
+  client?: () => Promise<SlackClient>;
+  channels: Record<string, EventMapping<SlackEvent>>;
+};
+/**
+ * Syncs Slack channels with board channels. Keys are channels by name
+ * (`'#prs'`) or ID (`'C0123ABC'`); values are a board channel (a two-way
+ * mirror) or a callback that handles every incoming event. The app joins public
+ * channels it isn't in; private ones need an invite.
+ */
+export declare function slack(options: SlackOptions): SlackProvider;
+export declare class SlackProvider extends ChatSyncProvider<SlackEvent> {
+  private readonly web;
+  private customize;
+  constructor(given: SlackOptions);
+  /**
+   * An agent's message goes out under its own name (`clever-lemur via vboard-factory`), and its
+   * picture when it has one Slack can show, instead of the app's, with the text's
+   * `**name**: ` label dropped. Without `chat:write.customize` it posts as the app, label and all.
+   */
+  post(target: string, kind: ResolvedTarget['kind'], body: ProviderPost): Promise<ProviderDelivery>;
+  /** An edit keeps the label out only where the message went out under the agent's name. */
+  edit(thread: string, message: string, body: ProviderPost): Promise<void>;
+  private postNamed;
+  /** Whether the app may set a message's username and icon (`chat:write.customize`), asked once. */
+  private canCustomize;
+  /** Whether a message Slack has went out under `name`. */
+  private sentAs;
+  /**
+   * Slack's link to the event's message, from `chat.getPermalink`, so it has the workspace's
+   * own host (Enterprise Grid included) and a reply's `thread_ts`. Null for an event without
+   * one message to link (a lifecycle event, or a deleted message Slack no longer has); throws
+   * when Slack won't say. It reads only the URL: nothing is synced or joined.
+   */
+  permalink(event: SlackEvent): Promise<string | null>;
+  eventId(key: string, input: ChatInput): string;
+  event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): SlackEvent;
+}
+//#endregion
+export { type UserTokens, withUserTokens };