@tightknitai/block-kitchen 0.9.9 → 0.10.0

package/dist/{palette-CKP8CK5Z.d.ts → palette-C8sPJuXx.d.ts}

@@ -1,4 +1,4 @@
-import { ComponentType, SVGProps } from 'react';
+import { ComponentType, SVGProps, ReactNode } from 'react';
 import { SectionBlock, HeaderBlock, DividerBlock, ContextBlock, ActionsBlock, ImageBlock, RichTextBlock, ImageElement, Button, ViewInputBlock } from 'slack-web-api-client';
 
 /**
@@ -571,6 +571,38 @@ interface SendPayload {
     channelId: string;
     blocks: SupportedBlock[];
     sendAsUser: boolean;
+    /**
+     * Values collected from the host's
+     * {@link BlockKitchenSendProps.renderSendExtras} fields, exactly as
+     * accumulated through {@link SendExtrasContext.setExtras}. Present
+     * (possibly `{}`) iff `renderSendExtras` is wired; absent otherwise, so
+     * existing consumers never see a new key.
+     */
+    extras?: Record<string, unknown>;
+}
+/**
+ * Context passed to {@link BlockKitchenSendProps.renderSendExtras} on every
+ * render of the send dialog. The `extras` object is owned by the dialog —
+ * it resets each time the dialog opens (alongside the channel and identity
+ * pickers) and is delivered on {@link SendPayload.extras} when the user
+ * confirms.
+ */
+interface SendExtrasContext {
+    /**
+     * Destination channel currently selected in the dialog, or `null` while
+     * channels are still loading / none is selected. Lets extras react to the
+     * destination (e.g. only offer cross-posting for some channels).
+     */
+    channelId: string | null;
+    /** Whether "post as the user" (vs. the app bot) is currently selected. */
+    sendAsUser: boolean;
+    /** The values collected so far. Render controlled inputs from these. */
+    extras: Record<string, unknown>;
+    /**
+     * Shallow-merges `patch` into {@link SendExtrasContext.extras}. Keys you
+     * never set simply don't appear in the payload.
+     */
+    setExtras: (patch: Record<string, unknown>) => void;
 }
 /**
  * Result returned from {@link BlockKitchenProps.onSend}.
@@ -580,6 +612,74 @@ interface SendResult {
     ok: boolean;
     error?: string;
 }
+/**
+ * Snapshot of the builder's validation verdict, reported through
+ * {@link BlockKitchenBaseProps.onValidationChange}. Mirrors exactly what the
+ * built-in issues chip / issues sheet show, so a host-owned CTA (e.g. in
+ * compose-only mode) can gate on the same verdict without re-running the
+ * validator and risking drift.
+ */
+interface ValidationSummary {
+    /** True iff the current draft has zero validation errors. */
+    valid: boolean;
+    /** Total error count — the number the toolbar's issues chip displays. */
+    errorCount: number;
+    /**
+     * Raw validator messages, verbatim from
+     * `@tightknitai/slack-block-kit-validator`. Block-scoped messages are
+     * rooted at `blocks[N]`, indexing into the payload `toSlackBlocks` emits.
+     */
+    errors: readonly string[];
+}
+/**
+ * Context handed to {@link PrimaryActionConfig.onClick}: everything a
+ * host-owned commitment step needs, captured at click time.
+ */
+interface PrimaryActionContext {
+    /**
+     * The current draft in the builder's native format — the same shape
+     * `onChange` reports and `initialBlocks` accepts. Persist this to re-open
+     * the draft later; run it through `toSlackBlocks` when you need the
+     * Slack-ready payload.
+     */
+    blocks: SupportedBlock[];
+    /**
+     * The validation verdict at click time — the same summary
+     * {@link BlockKitchenBaseProps.onValidationChange} reports.
+     */
+    validation: ValidationSummary;
+    /**
+     * The existing message currently loaded into the builder (via
+     * {@link BlockKitchenBaseProps.loading}), or `null` when composing a new
+     * message. Carries `channelId` + `ts` + the host's editability verdict, so
+     * a host-owned commitment step can offer "update in place" alongside
+     * "post as new".
+     */
+    loadedMessage: LoadedMessage | null;
+}
+/**
+ * A host-owned primary action for compose-only mode, rendered in the
+ * toolbar slot where the built-in "Review & send" button normally sits.
+ * Use it when the builder's commitment step belongs to your app — e.g. a
+ * message drafter whose CTA is "Save template" — but you still want the
+ * button inside the builder chrome. For a CTA outside the builder, skip
+ * this and use {@link BlockKitchenBaseProps.onChange} +
+ * {@link BlockKitchenBaseProps.onValidationChange} instead.
+ */
+interface PrimaryActionConfig {
+    /** Label + accessible name for the toolbar button. */
+    label: string;
+    /** Called on click with the current draft and validation verdict. */
+    onClick: (context: PrimaryActionContext) => void;
+    /**
+     * Disable the button while the draft has validation errors, mirroring the
+     * built-in Send gating. Defaults to `false`: a drafter typically allows
+     * committing a work-in-progress draft and surfaces the verdict in its own
+     * flow instead. The button is never disabled for an empty draft — gate on
+     * `context.blocks.length` in `onClick` if you need that.
+     */
+    disableWhenInvalid?: boolean;
+}
 /**
  * Which token can edit a loaded message, as computed by the host.
  * `chat.update` only edits a message authored by the calling token:
@@ -589,7 +689,7 @@ interface SendResult {
  */
 type EditableVia = 'bot' | 'user';
 /**
- * Input passed to {@link EditingConfig.onLoadMessage}. The user pastes a
+ * Input passed to {@link LoadingConfig.onLoadMessage}. The user pastes a
  * Slack message permalink (Slack's "Copy link"); the host parses
  * `channel + ts` out of it — the package never touches raw timestamps.
  */
@@ -597,38 +697,56 @@ interface LoadMessageInput {
     link: string;
 }
 /**
- * Result of loading an existing message for editing, computed by the host.
- *
- * On `ok`, the package enters edit mode: it hydrates the editor with
- * `blocks`, locks the destination to `channelId`, and constrains the
- * post-as identity to `editableVia`.
- *
- * On `!ok`, the package renders the host's `reason` inline and offers
- * "Open as a new message instead". If the message round-trips through the
- * block editor (e.g. someone else's block message), the host may include
- * `blocks` so that fallback can hydrate the draft; for non-block or
- * attachment-only messages, omit it.
+ * The existing message currently loaded into the builder: its source
+ * coordinates (`channelId` + `ts`), the host's editability verdict, and
+ * display metadata for the preview header / loaded banner. The `ok` branch
+ * of {@link LoadResult} is this plus `blocks`, so the loaded-message field
+ * list lives in exactly one place. Reported through
+ * {@link LoadingConfig.onLoadedMessageChange} and
+ * {@link PrimaryActionContext.loadedMessage}, and consumed by the built-in
+ * update flow ({@link BlockKitchenSendProps.onUpdate}).
  */
-type LoadResult = {
-    ok: true;
+interface LoadedMessage {
     channelId: string;
-    /** Channel name for the edit-mode badge (display only). Falls back to `channelId`. */
+    /**
+     * Channel name for the loaded banner (display only). Falls back to
+     * `channelId`.
+     */
     channelName?: string;
     ts: string;
-    blocks: SupportedBlock[];
     editableVia: EditableVia;
     workspaceName?: string;
     /**
-     * Display name of the existing message's author. When provided, the
-     * preview header shows it instead of `workspaceName`. Optional.
+     * Display name of the message's author. When provided, the preview header
+     * shows it instead of `workspaceName`. Optional.
      */
     username?: string;
     /**
-     * Avatar image URL of the existing message's author, shown in the
-     * preview header. Optional; ignored if it isn't a safe `http(s)` URL.
+     * Avatar image URL of the message's author, shown in the preview header.
+     * Optional; ignored if it isn't a safe `http(s)` URL.
      */
     iconUrl?: string;
-} | {
+}
+/**
+ * Result of loading an existing message, computed by the host.
+ *
+ * On `ok` — the {@link LoadedMessage} shape plus `blocks` — the package
+ * hydrates the editor with `blocks` and shows the loaded banner. Only the
+ * *update* flow ({@link BlockKitchenSendProps.onUpdate}) locks the
+ * destination to `channelId` and constrains the post-as identity to
+ * `editableVia`; the plain send dialog always posts a brand-new message
+ * with free channel/identity choice, loaded draft or not.
+ *
+ * On `!ok`, the package renders the host's `reason` inline and offers
+ * "Open as a new message instead". If the message round-trips through the
+ * block editor (e.g. someone else's block message), the host may include
+ * `blocks` so that fallback can hydrate the draft; for non-block or
+ * attachment-only messages, omit it.
+ */
+type LoadResult = (LoadedMessage & {
+    ok: true;
+    blocks: SupportedBlock[];
+}) | {
     ok: false;
     reason: string;
     blocks?: SupportedBlock[];
@@ -642,7 +760,7 @@ type LoadResult = {
     oauthUrl?: string;
 };
 /**
- * Payload passed to {@link EditingConfig.onUpdate}. Sibling to
+ * Payload passed to {@link BlockKitchenSendProps.onUpdate}. Sibling to
  * {@link SendPayload} but carries the source `channel + ts`. `chat.update`
  * requires re-sending the full blocks payload (no partial update).
  */
@@ -653,7 +771,7 @@ interface UpdatePayload {
     asUser: boolean;
 }
 /**
- * Result returned from {@link EditingConfig.onUpdate}. Mirrors
+ * Result returned from {@link BlockKitchenSendProps.onUpdate}. Mirrors
  * {@link SendResult}; `error` is rendered as-is.
  */
 interface UpdateResult {
@@ -662,7 +780,7 @@ interface UpdateResult {
 }
 /**
  * One entry in the "recent messages from this app" picker, returned by
- * {@link EditingConfig.loadRecentMessages} for the selected channel. These are
+ * {@link LoadingConfig.loadRecentMessages} for the selected channel. These are
  * editable-by-construction — the app authored them — so they load straight into
  * edit mode without a separate verdict round-trip. `editableVia` defaults to
  * `'bot'` when omitted.
@@ -683,43 +801,70 @@ interface RecentMessage {
     iconUrl?: string;
 }
 /**
- * Opt-in edit-mode configuration. Presence of {@link BlockKitchenProps.editing}
- * enables loading an existing message and dispatching an update; omit it to
- * keep the send-only behavior. The package stays integration-agnostic — it
- * makes no network calls and has no Slack-token knowledge; the host brokers
- * I/O and computes the editability verdict.
+ * Opt-in configuration for loading an existing message into the editor —
+ * a *composition* concern, so it works in both send mode and
+ * [compose-only mode](https://github.com/TightknitAI/block-kitchen#compose-only-mode-bring-your-own-send-flow).
+ * Presence of {@link BlockKitchenBaseProps.loading} adds the toolbar's
+ * "Find message" entry: the user pastes a Slack permalink (or picks a recent
+ * message), the host loads it, and the draft is hydrated with its blocks.
+ *
+ * What happens *after* composing stays mode-specific: in send mode, pair
+ * with {@link BlockKitchenSendProps.onUpdate} to update the message in place;
+ * in compose-only mode the host owns the commitment step and receives the
+ * loaded target via {@link PrimaryActionContext.loadedMessage} /
+ * {@link LoadingConfig.onLoadedMessageChange}.
  */
-interface EditingConfig {
+interface LoadingConfig {
     /**
      * Host parses the pasted permalink, fetches the message, and returns a
      * host-computed editability verdict plus blocks. See {@link LoadResult}.
      */
     onLoadMessage: (input: LoadMessageInput) => Promise<LoadResult>;
     /**
-     * Dispatches the update for the loaded message. Sibling to
-     * {@link BlockKitchenProps.onSend}; carries `channel + ts`.
+     * Optional. When provided (together with a channel source — see
+     * {@link LoadingConfig.loadChannels}), the load dialog adds a "recent
+     * messages from this app" picker alongside the paste-a-link input. The user
+     * first picks a channel; only then is this called with the chosen
+     * `channelId`, scoping the lookup to that single channel. Returns messages
+     * the app authored in that channel (editable-by-construction); picking one
+     * loads it directly. Omit to offer the paste-link entry only.
      */
-    onUpdate: (payload: UpdatePayload) => Promise<UpdateResult>;
+    loadRecentMessages?: (channelId: string) => Promise<RecentMessage[]>;
     /**
-     * Optional. When provided, the load dialog adds a "recent messages from this
-     * app" picker alongside the paste-a-link input. The user first picks a channel
-     * (reusing {@link BlockKitchenProps.loadChannels}); only then is this called
-     * with the chosen `channelId`, scoping the lookup to that single channel.
-     * Returns messages the app authored in that channel (editable-by-construction);
-     * picking one loads it straight into edit mode. Omit to offer the paste-link
-     * entry only.
+     * Channels used to scope the recent-messages picker. Only consulted when
+     * {@link LoadingConfig.loadRecentMessages} is provided. In send mode this
+     * defaults to the send integration's
+     * {@link BlockKitchenSendProps.loadChannels}; in compose-only mode there is
+     * no send integration, so provide it here or the picker is hidden.
      */
-    loadRecentMessages?: (channelId: string) => Promise<RecentMessage[]>;
+    loadChannels?: () => Promise<ChannelOption[]>;
     /**
-     * Optional. Pre-load a message straight into edit mode at mount, skipping the
-     * load dialog. Same shape the host returns from {@link onLoadMessage} on
-     * success. Read once at mount (like {@link BlockKitchenProps.initialBlocks});
-     * changing it later needs a remount. When set, its `blocks` seed the draft and
-     * {@link BlockKitchenProps.initialBlocks} is ignored.
+     * Optional. Pre-load a message at mount, skipping the load dialog. Same
+     * shape the host returns from {@link LoadingConfig.onLoadMessage} on
+     * success. Read once at mount (like
+     * {@link BlockKitchenBaseProps.initialBlocks}); changing it later needs a
+     * remount. When set, its `blocks` seed the draft and `initialBlocks` is
+     * ignored.
      */
     initialTarget?: Extract<LoadResult, {
         ok: true;
     }>;
+    /**
+     * Notified when the loaded message changes: the target after a successful
+     * load (including a mount-time {@link LoadingConfig.initialTarget}), and
+     * `null` when the user exits it ("Switch to a new message" / "Open as a
+     * new message instead"). Useful in compose-only mode to keep host state in
+     * sync — e.g. so a host-owned commitment step knows whether to offer
+     * "update in place" without waiting for a
+     * {@link PrimaryActionConfig.onClick}.
+     *
+     * Dedupe is by value, so this can re-fire for the same `channelId` + `ts`
+     * when the host's verdict or display metadata changed (e.g. `editableVia`
+     * flipping after a Slack sign-in) — key host state on the full target,
+     * not `ts` alone. Notifications flow only while `loading` is configured;
+     * removing the config mid-session is treated as unsubscribing.
+     */
+    onLoadedMessageChange?: (message: LoadedMessage | null) => void;
 }
 /**
  * A workspace custom emoji as configured in Slack. Mirrors the shape Slack's
@@ -794,11 +939,15 @@ interface Template {
     blocks: SupportedBlock[];
 }
 /**
- * Props for the top-level {@link BlockKitchen} component.
+ * Props shared by every {@link BlockKitchen} configuration.
  * The package is integration-agnostic: every I/O concern is brokered
  * through these props. The component never makes a network call itself.
+ *
+ * Combined with either {@link BlockKitchenSendProps} (the built-in send
+ * flow) or {@link BlockKitchenComposeOnlyProps} (compose-only: no send
+ * button, the host owns the send flow) to form {@link BlockKitchenProps}.
  */
-interface BlockKitchenProps {
+interface BlockKitchenBaseProps {
     /**
      * Workspace name shown in the preview chrome to mimic a Slack message header.
      * Cosmetic only.
@@ -813,6 +962,15 @@ interface BlockKitchenProps {
      * (URL search param, localStorage, etc).
      */
     onChange?: (blocks: SupportedBlock[]) => void;
+    /**
+     * Fires when the draft's validation verdict changes (piggybacking on the
+     * builder's own debounced validation pass — not on every keystroke, and
+     * not when the verdict is unchanged). Always scoped to the `message`
+     * surface, matching what Send would post. Useful in compose-only mode: a
+     * host-rendered CTA can disable itself on `!valid` using the exact verdict
+     * the issues sheet displays.
+     */
+    onValidationChange?: (summary: ValidationSummary) => void;
     /**
      * Optional hooks forwarded to the underlying `<Message>` component for
      * resolving user / channel / emoji directives. If omitted, those
@@ -831,33 +989,21 @@ interface BlockKitchenProps {
      */
     customEmojis?: CustomEmoji[];
     /**
-     * Returns channels available to send to. Called when the send dialog opens.
-     */
-    loadChannels: () => Promise<ChannelOption[]>;
-    /**
-     * Returns whether the current user can post as themselves and, if not, an
-     * OAuth URL to start the install flow.
-     */
-    loadSendAsUserStatus: () => Promise<SendAsUserStatus>;
-    /**
-     * Called when the user submits the send dialog. Should return
-     * `{ ok: true }` on success or `{ ok: false, error }` on failure.
-     */
-    onSend: (payload: SendPayload) => Promise<SendResult>;
-    /**
-     * Opt-in edit mode. When provided, the toolbar exposes an "Edit existing
-     * message" entry: the user pastes a Slack message link, the host loads it
-     * and returns an editability verdict ({@link EditingConfig.onLoadMessage}),
-     * and a successful load flips the primary action from Send to "Update
-     * message" ({@link EditingConfig.onUpdate}). Omit to keep today's send-only
-     * behavior. The user-token path reuses {@link BlockKitchenProps.loadSendAsUserStatus}.
+     * Opt-in: load an existing Slack message into the editor. Adds a
+     * "Find message" toolbar entry — the user pastes a permalink (or picks a
+     * recent message) and the draft is hydrated with its blocks. Loading is a
+     * *composition* concern, so it works in both send mode and compose-only
+     * mode. Pair with {@link BlockKitchenSendProps.onUpdate} (send mode) for
+     * the built-in update-in-place flow, or consume
+     * {@link PrimaryActionContext.loadedMessage} /
+     * {@link LoadingConfig.onLoadedMessageChange} (compose-only) to run your
+     * own.
      */
-    editing?: EditingConfig;
+    loading?: LoadingConfig;
     /**
      * Label + accessible name for the toolbar button that opens the
-     * load-message dialog (the edit-mode entry point). Defaults to
-     * `'Find message'`. Only shown when {@link BlockKitchenProps.editing} is set
-     * and no message is currently loaded.
+     * load-message dialog. Defaults to `'Find message'`. Only shown when
+     * {@link BlockKitchenBaseProps.loading} is configured.
      */
     loadButtonLabel?: string;
     /**
@@ -869,7 +1015,7 @@ interface BlockKitchenProps {
     updateButtonLabel?: string;
     /**
      * Label for the update dialog's final confirm button, which dispatches the
-     * update via {@link EditingConfig.onUpdate}. Defaults to `'Update message'`
+     * update via {@link BlockKitchenSendProps.onUpdate}. Defaults to `'Update message'`
      * (and shows `'Updating…'` while in flight).
      */
     confirmUpdateLabel?: string;
@@ -1022,5 +1168,93 @@ interface BlockKitchenProps {
      */
     theme?: BrandTheme | BrandPreset;
 }
+/**
+ * The send integration: the trio of I/O callbacks powering the built-in
+ * send dialog, plus opt-in edit mode (which reuses them). All-or-nothing by
+ * design — see {@link BlockKitchenComposeOnlyProps} for the alternative.
+ */
+interface BlockKitchenSendProps {
+    /**
+     * Returns channels available to send to. Called when the send dialog opens.
+     */
+    loadChannels: () => Promise<ChannelOption[]>;
+    /**
+     * Returns whether the current user can post as themselves and, if not, an
+     * OAuth URL to start the install flow.
+     */
+    loadSendAsUserStatus: () => Promise<SendAsUserStatus>;
+    /**
+     * Called when the user submits the send dialog. Should return
+     * `{ ok: true }` on success or `{ ok: false, error }` on failure.
+     */
+    onSend: (payload: SendPayload) => Promise<SendResult>;
+    /**
+     * Opt-in update-in-place mode. Dispatches the update for the loaded
+     * message — sibling to {@link BlockKitchenSendProps.onSend}, but carries
+     * the source `channel + ts`. When provided alongside
+     * {@link BlockKitchenBaseProps.loading}, a loaded message flips the
+     * primary action from Send to "Update message". Omit to keep send-only
+     * behavior: with `loading` alone, a loaded message can still be posted as
+     * a brand-new message. The user-token path reuses
+     * {@link BlockKitchenSendProps.loadSendAsUserStatus}.
+     */
+    onUpdate?: (payload: UpdatePayload) => Promise<UpdateResult>;
+    /**
+     * Renders host-defined fields inside the built-in send dialog, below the
+     * channel and identity pickers. Values collected via
+     * {@link SendExtrasContext.setExtras} are delivered on
+     * {@link SendPayload.extras} when the user confirms. Use this when the
+     * built-in flow is almost right and you need a few extra controls (a
+     * cross-post toggle, a custom sender name) without rebuilding the dialog.
+     */
+    renderSendExtras?: (context: SendExtrasContext) => ReactNode;
+    /**
+     * Unavailable with the send integration: the built-in Send/Update flow
+     * owns the toolbar's primary action. A host-owned
+     * {@link PrimaryActionConfig} exists only in compose-only mode.
+     */
+    primaryAction?: undefined;
+}
+/**
+ * Compose-only mode: omit the entire send integration and the builder
+ * renders no send button — it becomes a pure editor. The host owns the
+ * moment of commitment: mirror the draft via
+ * {@link BlockKitchenBaseProps.onChange}, gate a host-rendered CTA via
+ * {@link BlockKitchenBaseProps.onValidationChange}, and hand the finished
+ * payload (`toSlackBlocks(draft)`) to your own audience/delivery flow.
+ *
+ * The explicit `undefined` members make the send trio all-or-nothing at the
+ * type level: wiring only some of the three is a type error instead of a
+ * silently dead send button.
+ */
+interface BlockKitchenComposeOnlyProps {
+    loadChannels?: undefined;
+    loadSendAsUserStatus?: undefined;
+    onSend?: undefined;
+    /**
+     * The update-in-place flow (`chat.update`) depends on the send
+     * integration, so it is unavailable here. *Loading* an existing message
+     * is a composition concern and stays available via
+     * {@link BlockKitchenBaseProps.loading} — the host receives the loaded
+     * target ({@link PrimaryActionContext.loadedMessage} /
+     * {@link LoadingConfig.onLoadedMessageChange}) and owns any update flow.
+     */
+    onUpdate?: undefined;
+    /** Extends the built-in send dialog, which doesn't exist in this mode. */
+    renderSendExtras?: undefined;
+    /**
+     * Optional host-owned button rendered in the toolbar slot where the
+     * built-in "Review & send" normally sits — e.g. "Save template" for a
+     * message drafter. `onClick` receives the current draft and validation
+     * verdict ({@link PrimaryActionContext}). Omit it to render no primary
+     * action at all and place your CTA outside the builder.
+     */
+    primaryAction?: PrimaryActionConfig;
+}
+/**
+ * Props for the top-level {@link BlockKitchen} component: the shared base
+ * plus either the full send integration or none of it.
+ */
+type BlockKitchenProps = BlockKitchenBaseProps & (BlockKitchenSendProps | BlockKitchenComposeOnlyProps);
 
-export { type Template as $, type AlertBlock as A, type BlockKitchenProps as B, type CardBlock as C, type DataVisualizationBlock as D, type EditableVia as E, type FeedbackButtonSubobject as F, type PlanBlock as G, type HeaderLevel as H, type IconButtonElement as I, type PreviewHooks as J, type PreviewSurface as K, type LoadMessageInput as L, type MarkdownBlock as M, type PreviewTheme as N, type SendPayload as O, type PaletteSection as P, type SendResult as Q, type RecentMessage as R, type SendAsUserStatus as S, type SupportedBlock as T, type SupportedBlockType as U, type SupportedHeaderBlock as V, type TableBlock as W, type TableCell as X, type TableColumnSetting as Y, type TaskCardBlock as Z, type TaskCardStatus as _, type AlertLevel as a, type UpdatePayload as a0, type UpdateResult as a1, type UrlSourceElement as a2, type VideoBlock as a3, buildVariantById as a4, defaultPalette as a5, extraAlertVariant as a6, legacyInputVariants as a7, type BrandPreset as b, type BrandTheme as c, type BrandTokens as d, type BuilderBlock as e, type CarouselBlock as f, type CartesianChart as g, type ChannelOption as h, type Chart as i, type ChartAxisConfig as j, type ChartDataPoint as k, type ChartSeries as l, type ChartType as m, type ContainerBlock as n, type ContainerChildBlock as o, type ContextActionsBlock as p, type ContextActionsElement as q, type CustomEmoji as r, type EditingConfig as s, type FeedbackButtonsElement as t, type IconButtonIcon as u, type InputBlock as v, type LoadResult as w, type PaletteVariant as x, type PieChart as y, type PieChartSegment as z };
+export { type SupportedBlockType as $, type AlertBlock as A, type BlockKitchenBaseProps as B, type CardBlock as C, type DataVisualizationBlock as D, type EditableVia as E, type FeedbackButtonSubobject as F, type LoadingConfig as G, type HeaderLevel as H, type IconButtonElement as I, type PaletteVariant as J, type PieChart as K, type LoadMessageInput as L, type MarkdownBlock as M, type PieChartSegment as N, type PlanBlock as O, type PaletteSection as P, type PreviewHooks as Q, type PreviewSurface as R, type PreviewTheme as S, type PrimaryActionConfig as T, type PrimaryActionContext as U, type RecentMessage as V, type SendAsUserStatus as W, type SendExtrasContext as X, type SendPayload as Y, type SendResult as Z, type SupportedBlock as _, type AlertLevel as a, type SupportedHeaderBlock as a0, type TableBlock as a1, type TableCell as a2, type TableColumnSetting as a3, type TaskCardBlock as a4, type TaskCardStatus as a5, type Template as a6, type UpdatePayload as a7, type UpdateResult as a8, type UrlSourceElement as a9, type ValidationSummary as aa, type VideoBlock as ab, buildVariantById as ac, defaultPalette as ad, extraAlertVariant as ae, legacyInputVariants as af, type BlockKitchenComposeOnlyProps as b, type BlockKitchenProps as c, type BlockKitchenSendProps as d, type BrandPreset as e, type BrandTheme as f, type BrandTokens as g, type BuilderBlock as h, type CarouselBlock as i, type CartesianChart as j, type ChannelOption as k, type Chart as l, type ChartAxisConfig as m, type ChartDataPoint as n, type ChartSeries as o, type ChartType as p, type ContainerBlock as q, type ContainerChildBlock as r, type ContextActionsBlock as s, type ContextActionsElement as t, type CustomEmoji as u, type FeedbackButtonsElement as v, type IconButtonIcon as w, type InputBlock as x, type LoadResult as y, type LoadedMessage as z };

package/dist/palette.d.cts

@@ -1,3 +1,3 @@
-export { P as PaletteSection, x as PaletteVariant, T as SupportedBlock, U as SupportedBlockType, a4 as buildVariantById, a5 as defaultPalette, a6 as extraAlertVariant, a7 as legacyInputVariants } from './palette-CKP8CK5Z.cjs';
+export { P as PaletteSection, J as PaletteVariant, _ as SupportedBlock, $ as SupportedBlockType, ac as buildVariantById, ad as defaultPalette, ae as extraAlertVariant, af as legacyInputVariants } from './palette-C8sPJuXx.cjs';
 import 'react';
 import 'slack-web-api-client';

package/dist/palette.d.ts

@@ -1,3 +1,3 @@
-export { P as PaletteSection, x as PaletteVariant, T as SupportedBlock, U as SupportedBlockType, a4 as buildVariantById, a5 as defaultPalette, a6 as extraAlertVariant, a7 as legacyInputVariants } from './palette-CKP8CK5Z.js';
+export { P as PaletteSection, J as PaletteVariant, _ as SupportedBlock, $ as SupportedBlockType, ac as buildVariantById, ad as defaultPalette, ae as extraAlertVariant, af as legacyInputVariants } from './palette-C8sPJuXx.js';
 import 'react';
 import 'slack-web-api-client';