@nkootstra/block-kit 0.0.1 → 0.1.1

package/dist/index-FPjJcmn3.d.ts

@@ -0,0 +1,911 @@
+
+import { ComponentType, FocusEvent, MouseEvent, ReactElement, ReactNode } from "react";
+import { AnyBlock, MrkdwnElement, PlainTextElement } from "@slack/types";
+//#region src/types.d.ts
+/** A block or element as it appears in the JSON. Components narrow it to the fields they read. */
+interface Json {
+  type: string;
+  [field: string]: unknown;
+}
+interface BlockProps<T = Json> {
+  block: T;
+  /** The block's `block_id`, or the one generated for it. */
+  blockId: string;
+  index: number;
+}
+interface ElementProps<T = Json> {
+  element: T;
+  blockId: string;
+}
+//#endregion
+//#region src/Blocks.d.ts
+declare function Blocks({ blocks }: {
+  blocks: readonly (AnyBlock | Json)[];
+}): import("react").JSX.Element;
+//#endregion
+//#region src/blocks/Block.d.ts
+/** Renders one block. `index` is used for the generated block_id, as Slack does for blocks without one. */
+declare function Block({ block, index }: {
+  block: Json;
+  index: number;
+}): import("react").JSX.Element;
+//#endregion
+//#region src/blocks/index.d.ts
+declare const blockComponents: Record<string, ComponentType<BlockProps<any>>>;
+//#endregion
+//#region src/payloads.d.ts
+/**
+ * Builders for the exact JSON Slack sends to an app's request URL: `block_actions`,
+ * `view_submission` and `view_closed`. Shapes are cross-checked against `@slack/bolt`'s
+ * `BlockAction`, `ViewSubmitAction` and `ViewClosedAction` types and Slack's documented examples.
+ *
+ * These are plain functions (no React) so `@nkootstra/block-kit/server` and tests can use
+ * them without pulling in the renderer.
+ */
+interface PayloadTeam {
+  id: string;
+  domain: string;
+  enterprise_id?: string;
+  enterprise_name?: string;
+}
+interface PayloadUser {
+  id: string;
+  username?: string;
+  /** Only present for Home tab actions, per Slack's docs. */
+  name?: string;
+  team_id?: string;
+}
+/** Identity fields Slack stamps onto every payload. Defaulted so a demo/emulator works with no setup. */
+interface PayloadIdentity {
+  team?: PayloadTeam | null;
+  user?: PayloadUser;
+  apiAppId?: string;
+  token?: string;
+  triggerId?: string;
+  responseUrl?: string;
+}
+declare const DEFAULT_IDENTITY: {
+  team: PayloadTeam | null;
+  user: PayloadUser;
+  apiAppId: string;
+  token: string;
+  triggerId: string;
+  responseUrl: string;
+};
+type ResolvedIdentity = typeof DEFAULT_IDENTITY;
+/** The `message` surface's container: the message the block_actions/actions came from. */
+interface MessageContainer {
+  type: "message";
+  channelId?: string;
+  messageTs: string;
+  isEphemeral?: boolean;
+  /** Raw message object, if available, sent back verbatim as payload.message. */
+  message?: Record<string, unknown>;
+}
+/** A view as Slack would echo it back: enough fields to build view_submission/view_closed/block_actions. */
+interface ViewLike {
+  /** Slack assigns this at `views.open` time; default to a placeholder id for standalone previews. */
+  id?: string;
+  type: "modal" | "home";
+  callback_id?: string;
+  private_metadata?: string;
+  hash?: string;
+  blocks: AnyBlock[];
+  title?: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  } | null;
+  close?: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  } | null;
+  submit?: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  } | null;
+  root_view_id?: string | null;
+  previous_view_id?: string | null;
+  clear_on_close?: boolean;
+  notify_on_close?: boolean;
+  external_id?: string;
+}
+/** The `modal`/`home` surface's container: the view the block_actions came from. */
+interface ViewContainer {
+  type: "view";
+  view: ViewLike;
+}
+type Container = MessageContainer | ViewContainer;
+declare function toViewOutput(view: ViewLike, state: StateValues, identity: ResolvedIdentity): {
+  id: string;
+  team_id: string;
+  app_installed_team_id: string;
+  app_id: string;
+  bot_id: string;
+  callback_id: string;
+  type: "modal" | "home";
+  title: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  } | null;
+  close: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  } | null;
+  submit: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  } | null;
+  blocks: AnyBlock[];
+  private_metadata: string;
+  state: {
+    values: StateValues;
+  };
+  hash: string;
+  clear_on_close: boolean;
+  notify_on_close: boolean;
+  root_view_id: string;
+  previous_view_id: string | null;
+  external_id: string;
+};
+interface BuildBlockActionsPayloadOptions {
+  action: BlockAction;
+  state: StateValues;
+  container: Container;
+  identity?: PayloadIdentity;
+}
+interface BlockActionsPayloadBase {
+  type: "block_actions";
+  actions: BlockAction[];
+  team: PayloadTeam | null;
+  user: PayloadUser;
+  token?: string;
+  response_url?: string;
+  trigger_id?: string;
+  api_app_id?: string;
+}
+interface MessageBlockActionsPayload extends BlockActionsPayloadBase {
+  channel?: {
+    id: string;
+    name: string;
+  };
+  message: Record<string, unknown>;
+  state: {
+    values: StateValues;
+  };
+  container: {
+    type: "message";
+    message_ts: string;
+    channel_id?: string;
+    is_ephemeral: boolean;
+  };
+}
+interface ViewBlockActionsPayload extends BlockActionsPayloadBase {
+  view: ReturnType<typeof toViewOutput>;
+  container: {
+    type: "view";
+    view_id: string;
+  };
+}
+type BlockActionsPayload = MessageBlockActionsPayload | ViewBlockActionsPayload;
+/** Slack's `block_actions` payload, for either a message's or a view's interactive elements. */
+declare function buildBlockActionsPayload(options: BuildBlockActionsPayloadOptions & {
+  container: MessageContainer;
+}): MessageBlockActionsPayload;
+declare function buildBlockActionsPayload(options: BuildBlockActionsPayloadOptions & {
+  container: ViewContainer;
+}): ViewBlockActionsPayload;
+declare function buildBlockActionsPayload(options: BuildBlockActionsPayloadOptions): BlockActionsPayload;
+interface BuildViewSubmissionPayloadOptions {
+  view: ViewLike;
+  state: StateValues;
+  identity?: PayloadIdentity;
+  responseUrls?: Array<{
+    block_id: string;
+    action_id: string;
+    channel_id: string;
+    response_url: string;
+  }>;
+}
+/** Slack's `view_submission` payload, sent when the modal's Submit button is pressed. */
+declare function buildViewSubmissionPayload({ view, state, identity, responseUrls }: BuildViewSubmissionPayloadOptions): {
+  type: "view_submission";
+  team: PayloadTeam | null;
+  user: {
+    id: string;
+    name: string;
+    team_id: string | undefined;
+  };
+  api_app_id: string;
+  token: string;
+  trigger_id: string;
+  view: {
+    id: string;
+    team_id: string;
+    app_installed_team_id: string;
+    app_id: string;
+    bot_id: string;
+    callback_id: string;
+    type: "modal" | "home";
+    title: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    close: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    submit: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    blocks: AnyBlock[];
+    private_metadata: string;
+    state: {
+      values: StateValues;
+    };
+    hash: string;
+    clear_on_close: boolean;
+    notify_on_close: boolean;
+    root_view_id: string;
+    previous_view_id: string | null;
+    external_id: string;
+  };
+  response_urls: {
+    block_id: string;
+    action_id: string;
+    channel_id: string;
+    response_url: string;
+  }[];
+};
+interface BuildViewClosedPayloadOptions {
+  view: ViewLike;
+  state: StateValues;
+  identity?: PayloadIdentity;
+  /** True when Slack cleared the whole view stack (vs. just closing the top view). */
+  isCleared?: boolean;
+}
+/** Slack's `view_closed` payload, sent when the modal's close (X) button is pressed. */
+declare function buildViewClosedPayload({ view, state, identity, isCleared }: BuildViewClosedPayloadOptions): {
+  type: "view_closed";
+  team: PayloadTeam | null;
+  user: {
+    id: string;
+    name: string;
+    team_id: string | undefined;
+  };
+  api_app_id: string;
+  token: string;
+  view: {
+    id: string;
+    team_id: string;
+    app_installed_team_id: string;
+    app_id: string;
+    bot_id: string;
+    callback_id: string;
+    type: "modal" | "home";
+    title: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    close: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    submit: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    blocks: AnyBlock[];
+    private_metadata: string;
+    state: {
+      values: StateValues;
+    };
+    hash: string;
+    clear_on_close: boolean;
+    notify_on_close: boolean;
+    root_view_id: string;
+    previous_view_id: string | null;
+    external_id: string;
+  };
+  is_cleared: boolean;
+};
+/** The subset of `ack()` response actions a modal reacts to: validation errors, or view navigation. */
+type ViewResponseAction = {
+  response_action: "errors";
+  errors: Record<string, string>;
+} | {
+  response_action: "update";
+  view: ViewLike;
+} | {
+  response_action: "push";
+  view: ViewLike;
+} | {
+  response_action: "clear";
+};
+/** A static/external select option, as returned to a `block_suggestion` request. */
+interface SuggestionOption {
+  text: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  };
+  value: string;
+  description?: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  };
+  url?: string;
+}
+/** What an app answers a `block_suggestion` request with: flat options or labelled groups. */
+type OptionsResponse = {
+  options: SuggestionOption[];
+} | {
+  option_groups: Array<{
+    label: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    };
+    options: SuggestionOption[];
+  }>;
+};
+interface BuildBlockSuggestionPayloadOptions {
+  actionId: string;
+  blockId: string;
+  /** What the user has typed into the select's search box so far. */
+  value: string;
+  container: Container;
+  state: StateValues;
+  identity?: PayloadIdentity;
+}
+/** Slack's `block_suggestion` payload, sent while the user types into an `external_select`. */
+declare function buildBlockSuggestionPayload({ actionId, blockId, value, container, state, identity }: BuildBlockSuggestionPayloadOptions): {
+  container: {
+    type: "message";
+    message_ts: string;
+    channel_id: string | undefined;
+    is_ephemeral: boolean;
+    view_id?: undefined;
+  };
+  channel: {
+    id: string;
+    name: string;
+  } | undefined;
+  message: Record<string, unknown>;
+  type: "block_suggestion";
+  user: PayloadUser;
+  api_app_id: string;
+  token: string;
+  action_id: string;
+  block_id: string;
+  value: string;
+  team: PayloadTeam | null;
+} | {
+  container: {
+    type: "view";
+    view_id: string;
+    message_ts?: undefined;
+    channel_id?: undefined;
+    is_ephemeral?: undefined;
+  };
+  view: {
+    id: string;
+    team_id: string;
+    app_installed_team_id: string;
+    app_id: string;
+    bot_id: string;
+    callback_id: string;
+    type: "modal" | "home";
+    title: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    close: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    submit: {
+      type: "plain_text";
+      text: string;
+      emoji?: boolean;
+    } | null;
+    blocks: AnyBlock[];
+    private_metadata: string;
+    state: {
+      values: StateValues;
+    };
+    hash: string;
+    clear_on_close: boolean;
+    notify_on_close: boolean;
+    root_view_id: string;
+    previous_view_id: string | null;
+    external_id: string;
+  };
+  type: "block_suggestion";
+  user: PayloadUser;
+  api_app_id: string;
+  token: string;
+  action_id: string;
+  block_id: string;
+  value: string;
+  team: PayloadTeam | null;
+};
+type BlockSuggestionPayload = ReturnType<typeof buildBlockSuggestionPayload>;
+//#endregion
+//#region src/context.d.ts
+/**
+ * The action object Slack puts in `block_actions.actions[]`. The extra fields depend on the
+ * element type (`value`, `selected_option`, `selected_date`, ...), exactly as Slack sends them.
+ */
+interface BlockAction {
+  type: string;
+  action_id: string;
+  block_id: string;
+  action_ts: string;
+  text?: {
+    type: "plain_text";
+    text: string;
+    emoji?: boolean;
+  };
+  value?: string;
+  url?: string;
+  style?: "primary" | "danger";
+  [field: string]: unknown;
+}
+/** One entry of `view.state.values[block_id][action_id]`, e.g. `{ type: "datepicker", selected_date: "2024-01-01" }`. */
+interface ElementState {
+  type: string;
+  [field: string]: unknown;
+}
+/** Slack's `state.values`: element values keyed by block_id, then action_id. */
+type StateValues = Record<string, Record<string, ElementState>>;
+type Surface = "message" | "modal" | "home";
+/** What a user mention's profile card shows; everything but the name is optional. */
+interface UserProfile {
+  /** Display name, shown bold at the top of the card. */
+  name: string;
+  /** Full name, shown under the display name when it differs. */
+  realName?: string;
+  title?: string;
+  pronouns?: string;
+  avatarUrl?: string;
+  /** Custom status, e.g. `{ emoji: "palm_tree", text: "On vacation" }`. */
+  status?: {
+    emoji?: string;
+    text?: string;
+  };
+  /** IANA zone used for the card's "local time" row, e.g. `Europe/Amsterdam`. */
+  timeZone?: string;
+}
+/** Resolves ids in mrkdwn and rich text to display names. Return undefined when unknown. */
+interface Resolvers {
+  user?: (id: string) => string | undefined;
+  /**
+   * Profile details for the card that opens when a user mention is clicked. Falls back to the
+   * name from `user` when omitted.
+   */
+  userProfile?: (id: string) => UserProfile | undefined;
+  channel?: (id: string) => string | undefined;
+  usergroup?: (id: string) => string | undefined;
+}
+interface EmojiOptions {
+  /**
+   * Builds the image URL for a unified code point sequence such as `1f44d-1f3fd`. Defaults to the
+   * Apple set from emoji-datasource-apple on jsDelivr.
+   */
+  imageUrl?: (unified: string) => string;
+  /** Workspace custom emoji: name → image URL, or `alias:<name>`. */
+  custom?: Record<string, string>;
+}
+/** A modal opened through {@link ViewsApi}, with the validation errors last returned for it. */
+interface StackedView {
+  view: ViewLike & {
+    id: string;
+  };
+  errors: Record<string, string>;
+}
+/**
+ * Slack's `views.*` calls, for answering an interaction the way an app would: open a modal from a
+ * button, push a second one on top, or update one in place (e.g. after a `dispatch_action` input).
+ * Opened modals render on top of the provider's children, up to Slack's limit of 3.
+ */
+interface ViewsApi {
+  /** `views.open`: replaces any open modals with this one. Returns the new view's id. */
+  open: (view: ViewLike) => string;
+  /** `views.push`: stacks a modal on top of the current one. Returns the new view's id. */
+  push: (view: ViewLike) => string;
+  /**
+   * `views.update`: swaps a modal's content, keeping its id and any input values whose
+   * `block_id`/`action_id` are unchanged. Targets `viewId` or `externalId`, else the top modal.
+   */
+  update: (view: ViewLike, target?: {
+    viewId?: string;
+    externalId?: string;
+  }) => void;
+  /** Closes the top modal, returning to the one below it. */
+  close: () => void;
+  /** Closes every open modal. */
+  clear: () => void;
+  /** `views.publish`: replaces the content of the `<HomeTab>` rendered under this provider. */
+  publish: (view: ViewLike) => void;
+}
+/** New content for a message, as an app would send with `chat.update` or a `response_url`. */
+interface MessageUpdate {
+  blocks?: AnyBlock[];
+  text?: string;
+}
+/**
+ * Answers an interaction by changing the message it came from, like posting to its `response_url`
+ * with `replace_original` / `delete_original`, or calling `chat.update` / `chat.delete`.
+ */
+interface MessageApi {
+  /** Replaces the message's blocks and fallback text. */
+  update: (message: MessageUpdate) => void;
+  /** Removes the message. */
+  delete: () => void;
+}
+/** What an interaction happened in: the message/view it came from, and a handle to change the message. */
+interface SurfaceScopeValue {
+  container: Container;
+  message?: MessageApi;
+}
+interface ActionContext {
+  /** State of every input on the surface at the time of the action, like `state.values`. */
+  state: StateValues;
+  /** Opens, pushes or updates modals in response, like an app calling `views.*`. */
+  views: ViewsApi;
+  /** Set for actions in a `<Message>`: replaces or deletes that message. */
+  message?: MessageApi;
+}
+/** The second argument of `onPayload`. */
+interface PayloadContext {
+  views: ViewsApi;
+  /** Set for actions in a `<Message>`: replaces or deletes that message. */
+  message?: MessageApi;
+}
+/** What `onSubmit` may return: Slack's `response_action` ack, or nothing to just close the modal. */
+type SubmitResult = ViewResponseAction | undefined | void;
+interface BlockKitContextValue {
+  surface: Surface;
+  /** The provider's `theme`. Popovers, tooltips and dialogs render outside its wrapper, so they set it themselves. */
+  theme?: "light" | "dark";
+  onAction?: (action: BlockAction, context: ActionContext) => void;
+  /** Same actions as `onAction`, wrapped in the full Slack `block_actions` payload (team/user/container/...). */
+  onPayload?: (payload: ReturnType<typeof buildBlockActionsPayload>, context: PayloadContext) => void;
+  /** Called with a `view_submission` payload when a `<Modal>`'s Submit button is pressed. */
+  onSubmit?: (payload: ReturnType<typeof buildViewSubmissionPayload>, context: {
+    views: ViewsApi;
+  }) => SubmitResult | Promise<SubmitResult>;
+  /** Called with a `view_closed` payload when a `<Modal>`'s close (X) button is pressed. */
+  onClose?: (payload: ReturnType<typeof buildViewClosedPayload>) => void;
+  resolvers: Resolvers;
+  emoji: EmojiOptions;
+  /** Validation errors keyed by block_id, as returned in `response_action: "errors"`. */
+  errors: Record<string, string>;
+  /** IANA zone for `<!date>` tokens and date elements. Undefined means the viewer's zone. */
+  timeZone?: string;
+  state: StateValues;
+  /** Records an element's current value. Elements call this on every change. */
+  setValue: (blockId: string, actionId: string, value: ElementState | undefined) => void;
+  /**
+   * Reports an action, passing the current state along. `scope` is the surface it happened in;
+   * surfaces bind it for their elements, so elements never pass it themselves.
+   */
+  dispatch: (action: Partial<Pick<BlockAction, "action_ts">> & Omit<BlockAction, "action_ts">, scope?: SurfaceScopeValue) => void;
+  /** Identity fields (team/user/trigger_id/...) used to build full Slack payloads. */
+  identity: PayloadIdentity;
+  /**
+   * Registers the message/view a surface is rendering, so `dispatch` can build a full
+   * `block_actions` payload for `onPayload`. Surfaces call this via `useContainer`; not meant to
+   * be called directly.
+   */
+  setContainer: (container: Container | undefined) => void;
+  views: ViewsApi;
+  /**
+   * Asks the app for an `external_select`'s options with a `block_suggestion` payload. Resolves
+   * to undefined when there's no `onOptions` handler or no known container.
+   */
+  loadOptions?: (actionId: string, blockId: string, value: string, scope?: SurfaceScopeValue) => Promise<OptionsResponse | undefined>;
+  /** Set on a modal opened through `views`: the stack entry it renders. */
+  stackedView?: StackedView;
+  /** Applies a submit's `response_action` (or closes) for a stacked modal. */
+  respond?: (viewId: string, result: SubmitResult) => void;
+}
+interface BlockKitProviderProps {
+  children: ReactNode;
+  surface?: Surface;
+  onAction?: (action: BlockAction, context: ActionContext) => void;
+  /**
+   * Same actions as `onAction`, wrapped in the full Slack `block_actions` payload (team, user,
+   * container, response_url, ...) that an app's request URL would receive. Requires the surface
+   * being rendered (`<Message>`, `<Modal>`, `<HomeTab>`) to know its container, which they do
+   * automatically.
+   */
+  onPayload?: (payload: ReturnType<typeof buildBlockActionsPayload>, context: PayloadContext) => void;
+  /**
+   * Called with a `view_submission` payload when a `<Modal>`'s Submit button is pressed. For a
+   * modal opened through `views`, return a `response_action` (`errors`, `update`, `push`,
+   * `clear`) to react as Slack would, or nothing to close it. If it throws or rejects (the app
+   * couldn't be reached), the modal stays open.
+   */
+  onSubmit?: (payload: ReturnType<typeof buildViewSubmissionPayload>, context: {
+    views: ViewsApi;
+  }) => SubmitResult | Promise<SubmitResult>;
+  /** Called with a `view_closed` payload when a `<Modal>`'s close (X) button is pressed. */
+  onClose?: (payload: ReturnType<typeof buildViewClosedPayload>) => void;
+  /**
+   * Answers an `external_select`'s `block_suggestion` request with options, as an app's options
+   * load URL would. Without it, external selects accept a typed value on Enter instead.
+   */
+  onOptions?: (payload: BlockSuggestionPayload) => OptionsResponse | Promise<OptionsResponse>;
+  /** Called whenever an input value changes, with the full `state.values`. */
+  onStateChange?: (state: StateValues) => void;
+  resolvers?: Resolvers;
+  emoji?: EmojiOptions;
+  errors?: Record<string, string>;
+  timeZone?: string;
+  /** Team/user/trigger_id/... stamped onto payloads built for `onPayload`/`onSubmit`/`onClose`. */
+  identity?: PayloadIdentity;
+  /** Sets `data-theme` on a wrapper div so Slack's dark-mode CSS variables (Message.css) apply. */
+  theme?: "light" | "dark";
+}
+declare function BlockKitProvider(props: BlockKitProviderProps): import("react").JSX.Element;
+declare function useBlockKit(): BlockKitContextValue;
+/**
+ * Registers the message/view a surface (`<Message>`, `<Modal>`, `<HomeTab>`) is rendering, so
+ * `dispatch` can build a full `block_actions` payload for the provider's `onPayload`. Call once
+ * near the top of a surface component; re-call (it's cheap) whenever the container's identity
+ * changes.
+ */
+declare function useContainer(container: Container | undefined): void;
+interface SurfaceScopeProps extends SurfaceScopeValue {
+  /** Extra validation errors (by block_id) shown on top of the provider's. */
+  errors?: Record<string, string>;
+  children: ReactNode;
+}
+/**
+ * Binds the elements below it to one surface: their actions and options requests carry this
+ * container (and message handle), even when several surfaces share a provider. `<Message>`,
+ * `<Modal>` and `<HomeTab>` render one; custom surfaces can too.
+ */
+declare function SurfaceScope({ container, message, errors, children }: SurfaceScopeProps): import("react").JSX.Element;
+/**
+ * The view a `<HomeTab>` or standalone `<Modal>` should show: its `view` prop, or what the app
+ * last sent with `views.update`/`views.publish`. A new `view` prop (by content) wins again.
+ */
+declare function useLiveView<V extends ViewLike>(view: V, enabled?: boolean): {
+  view: V;
+  update: (next: ViewLike) => void;
+};
+//#endregion
+//#region src/elements/Element.d.ts
+/** Renders any interactive or image element. Unsupported types render a visible placeholder. */
+declare function Element({ element, blockId }: {
+  element: Json;
+  blockId: string;
+}): import("react").JSX.Element;
+//#endregion
+//#region src/elements/index.d.ts
+declare const elementComponents: Record<string, ComponentType<ElementProps<any>>>;
+//#endregion
+//#region src/Message.d.ts
+interface MessageApp {
+  name: string;
+  iconUrl?: string;
+}
+/** A reaction as Slack stores it on a message (`reactions[]` from conversations.history). */
+interface SlackReaction {
+  name: string;
+  count: number;
+  users?: string[];
+}
+/** One field of a legacy attachment (`attachments[].fields[]`). */
+interface SlackAttachmentField {
+  title: string;
+  value: string;
+  short?: boolean;
+}
+/** A legacy attachment, as Slack still renders it (colour bar, pretext, title, fields, footer). */
+interface SlackAttachment {
+  color?: string;
+  pretext?: string;
+  author_name?: string;
+  author_icon?: string;
+  author_link?: string;
+  title?: string;
+  title_link?: string;
+  text?: string;
+  fields?: SlackAttachmentField[];
+  image_url?: string;
+  footer?: string;
+  footer_icon?: string;
+  ts?: string | number;
+  /** Slack also lets attachments carry Block Kit blocks directly. */
+  blocks?: AnyBlock[];
+}
+/** A message object as returned by `conversations.history` / stored by `@emulators/slack`. */
+interface SlackMessageLike {
+  ts?: string;
+  channel?: string;
+  blocks?: AnyBlock[];
+  text?: string;
+  username?: string;
+  icon_url?: string;
+  icon_emoji?: string;
+  bot_profile?: {
+    name?: string;
+    icons?: {
+      image_72?: string;
+      image_48?: string;
+    };
+  };
+  edited?: {
+    ts?: string;
+    user?: string;
+  };
+  attachments?: SlackAttachment[];
+  reactions?: SlackReaction[];
+  reply_count?: number;
+  reply_users_count?: number;
+  latest_reply?: string;
+  subscribed?: boolean;
+}
+interface MessageProps {
+  blocks?: AnyBlock[];
+  /** Fallback text. Slack shows it only when there are no blocks. */
+  text?: string;
+  app?: MessageApp;
+  /** Message timestamp (Slack `ts`, seconds). Defaults to now. */
+  ts?: string | number;
+  /** IANA zone for the displayed time. Defaults to the viewer's zone, like Slack. */
+  timeZone?: string;
+  /**
+   * A Slack message object (e.g. from `conversations.history`, or as stored by
+   * `@emulators/slack`). When given, it supplies blocks/text/ts and the sender header
+   * (username/icon/bot_profile), plus attachments, reactions, thread summary and edited marker.
+   * `blocks`/`text`/`app`/`ts` above still work standalone for simple previews.
+   */
+  message?: SlackMessageLike;
+  /** The channel the message is in. Used for the `block_actions` container Slack would send. */
+  channelId?: string;
+  /** Slack's "Only visible to you" marker, shown for ephemeral messages. */
+  isEphemeral?: boolean;
+}
+/** A message as it appears in a Slack channel: avatar, app name, APP badge, time and blocks. */
+declare function Message({ blocks, text, app, ts, timeZone, message, channelId, isEphemeral }: MessageProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/Mrkdwn.d.ts
+interface MrkdwnProps {
+  text: string;
+  /** Slack's `verbatim` flag. When false (the default), bare URLs are linked. */
+  verbatim?: boolean;
+  /** Pixel size for `:emoji:` images. Defaults to 22 (Slack's inline size at 15px text). */
+  emojiSize?: number;
+}
+/** Renders a Slack mrkdwn string. */
+declare function Mrkdwn({ text, verbatim, emojiSize }: MrkdwnProps): import("react").JSX.Element;
+//#endregion
+//#region src/surfaces/HomeTab.d.ts
+interface HomeTabView extends ViewLike {
+  type: "home";
+}
+interface HomeTabProps {
+  view: HomeTabView;
+}
+/** A Slack Home tab: just its blocks, laid out full width like Slack's App Home. */
+declare function HomeTab({ view: viewProp }: HomeTabProps): import("react").JSX.Element;
+//#endregion
+//#region src/surfaces/Modal.d.ts
+interface ModalView extends ViewLike {
+  type: "modal";
+}
+interface ModalProps {
+  view: ModalView;
+  /** App icon shown before the title, as in Slack's own modal chrome. */
+  icon?: string;
+}
+/** A Slack modal: header (icon + title + close), a scrollable body of blocks, and a close/submit footer. */
+declare function Modal({ view: viewProp, icon }: ModalProps): import("react").JSX.Element;
+//#endregion
+//#region src/surfaces/View.d.ts
+type AnyView = ModalView | HomeTabView;
+interface ViewProps {
+  view: AnyView;
+  /** App icon shown before the modal title. No effect on the Home tab (Slack doesn't show it there). */
+  icon?: string;
+}
+/** Dispatches a Slack `view` payload (as from `views.open`/`views.publish`) to `<Modal>` or `<HomeTab>`. */
+declare function View({ view, icon }: ViewProps): import("react").JSX.Element;
+//#endregion
+//#region src/Text.d.ts
+type TextObject = PlainTextElement | MrkdwnElement;
+interface TextProps {
+  text: TextObject;
+  /** Pixel size for `:emoji:` images. Defaults to 22 (Slack's inline size at 15px text). */
+  emojiSize?: number;
+}
+/** Renders a Block Kit text object. */
+declare function Text({ text, emojiSize }: TextProps): import("react").JSX.Element;
+//#endregion
+//#region src/Tooltip.d.ts
+type Placement = "top" | "bottom";
+type AnchorProps = {
+  onMouseEnter?: (e: MouseEvent) => void;
+  onMouseLeave?: (e: MouseEvent) => void;
+  onFocus?: (e: FocusEvent) => void;
+  onBlur?: (e: FocusEvent) => void;
+  "aria-describedby"?: string;
+};
+interface TooltipProps {
+  /** Tooltip content; nothing is rendered when empty. */
+  label: ReactNode;
+  /** A single element to anchor to; it receives the hover/focus handlers. */
+  children: ReactElement<AnchorProps>;
+  /** Preferred side; flips to the other one when there's no room. Defaults to `top`. */
+  placement?: Placement;
+}
+/**
+ * Slack's `c-tooltip`: a dark, bold 13px bubble with an arrow, shown above (or below) its anchor
+ * after a short hover or on keyboard focus. It appears and disappears without animation, as in
+ * Slack. Portalled to `<body>` so scroll containers and `overflow: hidden` can't clip it.
+ */
+declare function Tooltip({ label, children, placement }: TooltipProps): import("react").JSX.Element;
+//#endregion
+//#region src/UserMention.d.ts
+interface UserMentionProps {
+  /** Slack user id, e.g. `U0123ABC`. */
+  id: string;
+  /** Display name, rendered as `@name`. */
+  name: string;
+}
+/**
+ * A resolved `@user` mention. Clicking it (or Enter/Space when focused) opens a profile card like
+ * Slack's `p-member_profile_card` popover: avatar, names, title, status and local time, filled from
+ * `resolvers.userProfile` and falling back to the display name alone.
+ */
+declare function UserMention({ id, name }: UserMentionProps): import("react").JSX.Element;
+//#endregion
+//#region src/validation.d.ts
+/**
+ * The checks Slack's client runs on a modal before it sends `view_submission`: required inputs,
+ * text length, number format/range, and email/URL format. A failing field shows its message under
+ * the input and the submission never reaches the app.
+ *
+ * Slack doesn't document the exact wording; these follow its client's phrasing as closely as we
+ * know it and live here so they can be adjusted in one place.
+ */
+declare const VALIDATION_MESSAGES: {
+  required: string;
+  minLength: (n: number) => string;
+  maxLength: (n: number) => string;
+  number: string;
+  wholeNumber: string;
+  minValue: (min: string) => string;
+  maxValue: (max: string) => string;
+  email: string;
+  url: string;
+};
+/**
+ * Validates a view's `input` blocks against `state.values` the way Slack's client does before a
+ * submission. Returns errors keyed by block_id (the shape of `response_action: "errors"`); empty
+ * when the view may be submitted.
+ */
+declare function validateView(blocks: readonly Json[] | readonly unknown[], state: StateValues): Record<string, string>;
+//#endregion
+export { BlockSuggestionPayload as $, BlockAction as A, StackedView as B, SlackAttachment as C, BlockProps as Ct, elementComponents as D, SlackReaction as E, EmojiOptions as F, SurfaceScopeProps as G, SubmitResult as H, MessageApi as I, ViewsApi as J, SurfaceScopeValue as K, MessageUpdate as L, BlockKitProvider as M, BlockKitProviderProps as N, Element as O, ElementState as P, BlockActionsPayload as Q, PayloadContext as R, MessageProps as S, Blocks as St, SlackMessageLike as T, Json as Tt, Surface as U, StateValues as V, SurfaceScope as W, useContainer as X, useBlockKit as Y, useLiveView as Z, HomeTabView as _, buildBlockSuggestionPayload as _t, Tooltip as a, MessageBlockActionsPayload as at, Message as b, blockComponents as bt, TextObject as c, PayloadIdentity as ct, ViewProps as d, SuggestionOption as dt, BuildBlockActionsPayloadOptions as et, Modal as f, ViewBlockActionsPayload as ft, HomeTabProps as g, buildBlockActionsPayload as gt, HomeTab as h, ViewResponseAction as ht, UserMentionProps as i, Container as it, BlockKitContextValue as j, ActionContext as k, AnyView as l, PayloadTeam as lt, ModalView as m, ViewLike as mt, validateView as n, BuildViewClosedPayloadOptions as nt, TooltipProps as o, MessageContainer as ot, ModalProps as p, ViewContainer as pt, UserProfile as q, UserMention as r, BuildViewSubmissionPayloadOptions as rt, Text as s, OptionsResponse as st, VALIDATION_MESSAGES as t, BuildBlockSuggestionPayloadOptions as tt, View as u, PayloadUser as ut, Mrkdwn as v, buildViewClosedPayload as vt, SlackAttachmentField as w, ElementProps as wt, MessageApp as x, Block as xt, MrkdwnProps as y, buildViewSubmissionPayload as yt, Resolvers as z };
+//# sourceMappingURL=index-FPjJcmn3.d.ts.map