@knitify/vue 1.0.0 → 2.0.0

package/dist/types/components/Badge/types.d.ts

@@ -1,5 +1,7 @@
 import { Size, Variant } from '../../types';
 export type KBadgeProps = {
+    /** Tighter padding for a badge sitting on an avatar or in a dense list. */
+    compact?: boolean;
     pill?: boolean;
     size?: Size;
     subtle?: boolean;

package/dist/types/components/Chat/KChatDivider.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KChatDividerProps, KChatDividerSlots } from './types';
+type __VLS_Slots = KChatDividerSlots;
+declare const __VLS_base: import("vue").DefineComponent<KChatDividerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KChatDividerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Chat/KChatMessageActions.vue.d.ts

@@ -0,0 +1,18 @@
+import type { KChatMessageActionsProps, KChatMessageActionsSlots } from './types';
+type __VLS_Slots = KChatMessageActionsSlots;
+declare const __VLS_base: import("vue").DefineComponent<KChatMessageActionsProps, {
+    hold: () => void;
+    release: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    action: (key: string, item?: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<KChatMessageActionsProps> & Readonly<{
+    onAction?: ((key: string, item?: string | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Chat/KChatNotice.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KChatNoticeProps, KChatNoticeSlots } from './types';
+type __VLS_Slots = KChatNoticeSlots;
+declare const __VLS_base: import("vue").DefineComponent<KChatNoticeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KChatNoticeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Chat/KChatPrompt.vue.d.ts

@@ -16,8 +16,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {
 }>, {
     disabled: boolean;
     busy: boolean;
-    maxRows: number;
     placeholder: string;
+    maxRows: number;
     newlineOnEnter: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/components/Chat/types.d.ts

@@ -1,4 +1,7 @@
+import type { Intent } from '../../types';
 export type KChatProps = {
+    /** Stacks every message's actions under its bubble instead of beside it. */
+    actionsBottom?: boolean;
     ai?: boolean;
     autoscroll?: boolean;
     busy?: boolean;
@@ -18,6 +21,93 @@ export type KChatMessageProps = {
 export type KChatMessageSlots = {
     default?(): any;
     time?(): any;
+    /** The hover row beside or below the bubble. Put a `KChatMessageActions` here. */
+    actions?(): any;
+};
+/**
+ * One entry in a `KChatMessageActions` set. A consuming project computes these
+ * per message, which is where sender, status and permission logic belongs —
+ * the component only renders what it is handed.
+ */
+export type KChatAction = {
+    /** Identifies the action in the `action` event. Unique within its level. */
+    key: string;
+    /** Sprite id, e.g. `reply`. Omitted for a text-only dropdown row. */
+    icon?: string;
+    /** Tooltip and accessible name. */
+    label: string;
+    disabled?: boolean;
+    /**
+     * Semantic color, for destructive rows. Applies to top-level actions only
+     * — a row nested under `items` renders as a plain `KDropdownItem`, which
+     * has no intent prop, so `intent` is silently ignored there.
+     */
+    intent?: Intent;
+    /** Defaults to `true`. A hidden action renders nothing at all. */
+    visible?: boolean;
+    /** Presence turns the action into a dropdown of these rows. */
+    items?: KChatAction[];
+    /** A rule between rows. Only meaningful inside `items`. */
+    divider?: boolean;
+};
+export type KChatMessageActionsProps = {
+    /**
+     * The action set. Defaults to react, reply and more; passing an array
+     * replaces it outright rather than adding to it.
+     */
+    actions?: KChatAction[];
+};
+export type KChatMessageActionsEmits = {
+    /**
+     * A top-level action's key, plus the nested key when the choice came from a
+     * dropdown row. Switch on `key` rather than binding a handler per button.
+     */
+    action: [key: string, item?: string];
+};
+export type KChatMessageActionsSlots = {
+    /**
+     * Replaces the whole row, keeping the reveal behaviour and the latch. `hold`
+     * and `release` are the same pair the built-in dropdown binds, so a custom
+     * overlay can keep the row up while it is open.
+     */
+    default?(props: {
+        hold: () => void;
+        release: () => void;
+    }): any;
+    /**
+     * Fills the `react` action, which exists precisely because a panel-shaped
+     * overlay — an emoji picker — cannot be described by a `KChatAction`.
+     */
+    react?(props: {
+        hold: () => void;
+        release: () => void;
+    }): any;
+    /**
+     * Dropdown rows for the `more` action, replacing its `items`. Rows you
+     * supply here are your own markup — only the rows generated from `items`
+     * emit the `action` event, so a row rendered through this slot must wire
+     * up its own click handling.
+     */
+    more?(): any;
+};
+export type KChatDividerProps = {
+    /** Centred label. Omit for an unbroken rule. */
+    label?: string;
+};
+/**
+ * An event in the conversation — "Call ended at 01:48 PM", "You ended the
+ * meeting". Distinct from `KChatDivider`, which marks a boundary between
+ * messages rather than being content itself.
+ */
+export type KChatNoticeProps = {
+    /** The notice text. The default slot overrides it, for markup or a link. */
+    label?: string;
+};
+export type KChatNoticeSlots = {
+    default?(): any;
+};
+export type KChatDividerSlots = {
+    default?(): any;
 };
 export type KChatPromptProps = {
     busy?: boolean;

package/dist/types/components/ChatDock/KChatDock.vue.d.ts

@@ -0,0 +1,45 @@
+import type { KChatDockProps, KChatDockSlots } from './types';
+type __VLS_Slots = KChatDockSlots;
+declare function openPanel(): void;
+declare function closePanel(): void;
+declare function togglePanel(): void;
+/**
+ * Re-runs core's filter against whatever the search field currently holds.
+ *
+ * `filter()` is one-shot: it stamps `is-hidden` on the items present when it
+ * runs and recomputes the empty element only then. Rows a framework renders
+ * later — an async list resolving, a refresh adding rows while a query is
+ * active — are therefore unfiltered, and the empty element keeps whatever the
+ * last call decided (`closePanel()` filters on an empty list, so it un-hides
+ * it). A caller that renders the panel's items itself calls this after the
+ * rows change.
+ */
+declare function refilter(): void;
+declare const __VLS_base: import("vue").DefineComponent<KChatDockProps, {
+    openPanel: typeof openPanel;
+    closePanel: typeof closePanel;
+    togglePanel: typeof togglePanel;
+    refilter: typeof refilter;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (id: string, opened: boolean) => any;
+    search: (query: string) => any;
+    reflow: () => any;
+    launcher: () => any;
+    panel: (open: boolean) => any;
+    activate: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<KChatDockProps> & Readonly<{
+    onSelect?: ((id: string, opened: boolean) => any) | undefined;
+    onSearch?: ((query: string) => any) | undefined;
+    onReflow?: (() => any) | undefined;
+    onLauncher?: (() => any) | undefined;
+    onPanel?: ((open: boolean) => any) | undefined;
+    onActivate?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ChatDock/KChatDockItem.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KChatDockItemProps, KChatDockItemSlots } from './types';
+type __VLS_Slots = KChatDockItemSlots;
+declare const __VLS_base: import("vue").DefineComponent<KChatDockItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KChatDockItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ChatDock/KChatDockPanel.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KChatDockPanelProps, KChatDockPanelSlots } from './types';
+type __VLS_Slots = KChatDockPanelSlots;
+declare const __VLS_base: import("vue").DefineComponent<KChatDockPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KChatDockPanelProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ChatDock/KChatWindow.vue.d.ts

@@ -0,0 +1,27 @@
+import type { KChatWindowProps, KChatWindowSlots, KChatWindowState } from './types';
+type __VLS_Props = KChatWindowProps;
+type __VLS_Slots = KChatWindowSlots;
+declare function expand(): void;
+declare function rail(): void;
+type __VLS_ModelProps = {
+    'state'?: KChatWindowState;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    expand: typeof expand;
+    rail: typeof rail;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    "update:state": (value: KChatWindowState) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    "onUpdate:state"?: ((value: KChatWindowState) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ChatDock/KMessenger.vue.d.ts

@@ -0,0 +1,23 @@
+import type { ChatDockStore, KMessengerProps, KMessengerSlots } from './messenger-types';
+type __VLS_Slots = KMessengerSlots;
+declare const __VLS_base: import("vue").DefineComponent<KMessengerProps, ChatDockStore, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (kind: import("./messenger-types").ChatDockErrorKind, id: string | undefined, error: unknown) => any;
+    send: (message: import("./messenger-types").ChatMessage) => any;
+    open: (id: string) => any;
+    close: (id: string) => any;
+    receive: (message: import("./messenger-types").ChatMessage) => any;
+}, string, import("vue").PublicProps, Readonly<KMessengerProps> & Readonly<{
+    onError?: ((kind: import("./messenger-types").ChatDockErrorKind, id: string | undefined, error: unknown) => any) | undefined;
+    onSend?: ((message: import("./messenger-types").ChatMessage) => any) | undefined;
+    onOpen?: ((id: string) => any) | undefined;
+    onClose?: ((id: string) => any) | undefined;
+    onReceive?: ((message: import("./messenger-types").ChatMessage) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ChatDock/keys.d.ts

@@ -0,0 +1,98 @@
+import type { InjectionKey, ShallowRef } from 'vue';
+import type Knitify from '@knitify/core';
+export type ChatDockInstance = InstanceType<typeof Knitify.modules.ChatDock>;
+/**
+ * What `withModule` did, so a caller can react to each outcome distinctly:
+ *
+ * - `'called'` — the callback ran against a live module. Anything the caller
+ *   wanted to tell core has been told.
+ * - `'deferred'` — a dock is present but its first `init()` has not run yet,
+ *   so nothing may reach core (see `withModule`). The callback did **not**
+ *   run; the caller must record its intent through `declare` instead, and the
+ *   dock replays it the moment calling core becomes safe.
+ * - `'unavailable'` — there is no module to call at all: no `KChatDock`
+ *   ancestor, or the dock's own root is gone. The callback did **not** run and
+ *   nothing was or will be recorded, so a caller must not update bookkeeping
+ *   that claims core was told something.
+ */
+export type ChatDockCallResult = 'called' | 'deferred' | 'unavailable';
+export type ChatDockContext = {
+    /**
+     * **The only way to reach core from anywhere in this component pair.** The
+     * module instance is deliberately not exposed: a call site that cannot get
+     * hold of it cannot skip the gate below by accident, which is what four
+     * successive rounds of path-specific patching kept failing to prevent.
+     *
+     * The gate: no core call may happen before the dock's own first deferred
+     * `init()` has run. Every core method reflows synchronously before it
+     * returns, and a reflow dispatches `kt.chatdock.rail`/`.unrail` to whichever
+     * windows changed — but a child window attaches those listeners from a
+     * template-ref watcher, which lands a flush *after* its parent's
+     * `onMounted`, and Vue orders pre-flush jobs by component creation order, so
+     * the dock's own watchers and an earlier sibling's watchers all run while a
+     * later sibling is still deaf. An event dropped that way is lost for good:
+     * Vue never re-patches a `class` binding whose rendered string is unchanged,
+     * so core's directly-set `is-railed` survives on the element while
+     * `v-model:state` (and `aria-expanded`) stay wrong forever, and every later
+     * reflow is a no-op diff that never repairs it.
+     *
+     * Skipping a pre-init call costs nothing, which is what makes the gate safe
+     * rather than merely cautious: the deferred `init()` applies every pending
+     * declaration and reflows anyway, so it subsumes whatever was skipped.
+     *
+     * Also flushes any pending declarations through core immediately before
+     * running the callback, so a `reflow()` never computes capacity against a
+     * window core has not yet been told is railed.
+     */
+    withModule: (run: (module: ChatDockInstance) => void) => ChatDockCallResult;
+    /**
+     * Records whether a window should be railed once the dock next applies its
+     * declarations — no class, no attribute, no method call yet. `KChatDock`
+     * plays every recorded declaration through core itself, from its deferred
+     * first `init()` and again before every later core call (see `withModule`),
+     * which are the only points every window is guaranteed to have already
+     * attached its own `kt.chatdock.*` listeners.
+     *
+     * This is where state intent goes whenever `withModule` reports
+     * `'deferred'`, and where a window's own initial non-expanded state goes at
+     * mount.
+     *
+     * With only two states left, this only ever records `railed` — an
+     * `'expanded'` window needs nothing (that's what a freshly-seeded window
+     * already is), and `railed` needs a core call because only core's `rail()`
+     * sets the `data-kt-chat-window-minimized` marker `reflow()` reads to tell
+     * an explicit minimize apart from a window merely ranked below capacity.
+     *
+     * Idempotent both ways: declaring the same element `railed` repeatedly, or
+     * un-declaring it (passing `false`) before it's ever applied, just leaves
+     * one net entry (or none) — whichever a window's most recent write before
+     * the dock's next apply says is true.
+     */
+    declare: (element: HTMLElement, railed: boolean) => void;
+    /**
+     * The rail element, as a ref, so a window can teleport its head into it.
+     *
+     * A ref rather than the element itself because the rail is rendered by the
+     * dock and a window may set up before it resolves; `<Teleport defer>`
+     * handles a target that appears later in the same tree, and the ref is what
+     * lets the window react when it does.
+     *
+     * This is not a way around the gate: teleporting renders markup, it does
+     * not call core. Every core call still goes through `withModule`.
+     */
+    rail: Readonly<ShallowRef<HTMLElement | null>>;
+    /**
+     * The popover list element, as a ref, so a window can teleport its row into
+     * it. Same shape and reasoning as `rail`: the dock renders it, a window may
+     * set up before it resolves, and `<Teleport defer>` handles a target that
+     * appears later in the same tree.
+     */
+    list: Readonly<ShallowRef<HTMLElement | null>>;
+    /**
+     * The row zone element, as a ref, so `KChatDockPanel` can teleport into it.
+     * Same shape and reasoning as `rail` and `list`. The panel's `order: -1`
+     * places it beside the rail regardless of where the teleport appends it.
+     */
+    panel: Readonly<ShallowRef<HTMLElement | null>>;
+};
+export declare const chatDockKey: InjectionKey<ChatDockContext>;

package/dist/types/components/ChatDock/messenger-types.d.ts

@@ -0,0 +1,280 @@
+import type { ComputedRef, Ref } from 'vue';
+export type ChatConversation = {
+    id: string;
+    name: string;
+    /** Image URL; the avatar falls back to initials from `name`. */
+    avatar?: string;
+    /** Last message line, shown in the panel row. */
+    preview?: string;
+    unread?: number;
+    /** ISO timestamp; when present the panel sorts newest first. */
+    updatedAt?: string;
+    /**
+     * Untouched by the store — carry app-specific payload through to the slots.
+     * Replaced, not merged, when `refreshConversations` returns a conversation
+     * that carries one: the merge is a shallow spread.
+     */
+    meta?: unknown;
+};
+export type ChatMessage = {
+    id: string;
+    conversationId: string;
+    text: string;
+    /** `true` for the current user; drives `KChatMessage`'s `sender`. */
+    sender: boolean;
+    /** Display string, e.g. "10:42 AM". */
+    time?: string;
+    /** ISO timestamp, for ordering by the server. */
+    sentAt?: string;
+    /** Optimistic send in flight; cleared when `sendMessage` resolves. */
+    pending?: boolean;
+    /** `sendMessage` rejected; the message shows a retry control. */
+    failed?: boolean;
+    /**
+     * Untouched by the store — carry app-specific payload through to the slots.
+     * An optimistic message created by `send()` has none; the message returned
+     * by `sendMessage` replaces it wholesale, so `meta` appears when the server
+     * response does.
+     */
+    meta?: unknown;
+};
+export type ChatMessagesPage = {
+    messages: ChatMessage[];
+    /** `null` or `undefined` means there is nothing older. */
+    nextCursor?: string | null;
+};
+export type ChatDockLoaders = {
+    loadConversations: () => Promise<ChatConversation[]>;
+    /** Chronological within the page (oldest first). `cursor` asks for older. */
+    loadMessages: (id: string, cursor?: string) => Promise<ChatMessagesPage>;
+    /** Optional; without it the composer is hidden. */
+    sendMessage?: (id: string, text: string) => Promise<ChatMessage>;
+    /** Optional; called when a window expands. Unread is zeroed locally either way. */
+    markRead?: (id: string) => Promise<void>;
+};
+export type ChatDockOptions = {
+    /** Drop messages, cursor and draft when a window closes. Default `false`. */
+    evictOnClose?: boolean;
+};
+export type ChatWindowState = 'closed' | 'expanded' | 'railed';
+export type LoadState = 'idle' | 'loading' | 'loaded' | 'error';
+export type ChatEntry = {
+    conversation: ChatConversation;
+    window: ChatWindowState;
+    messages: ChatMessage[];
+    /** `undefined` until the first page loads; `null` when nothing older exists. */
+    cursor: string | null | undefined;
+    loading: LoadState;
+    loadingOlder: boolean;
+    error?: unknown;
+    draft: string;
+};
+export type ChatDockErrorKind = 'conversations' | 'messages' | 'send';
+export type ChatDockStore = {
+    /** Sorted newest first when `updatedAt` is present on every entry. */
+    conversations: ComputedRef<ChatConversation[]>;
+    entries: Record<string, ChatEntry>;
+    /** Ids whose window is not `'closed'`, most recently opened first. */
+    openIds: ComputedRef<string[]>;
+    listLoading: Ref<LoadState>;
+    listError: Ref<unknown>;
+    query: Ref<string>;
+    /** Whether a composer can be rendered at all. */
+    canSend: boolean;
+    refreshConversations: () => Promise<void>;
+    open: (id: string) => Promise<void>;
+    /**
+     * Shows a window again without treating it as a user-initiated open: no
+     * rank change, no unread reset, no `markRead`, no `'open'` event. For a
+     * reflow un-railing a window; use `open` for a real choice.
+     */
+    expand: (id: string) => Promise<void>;
+    minimize: (id: string) => void;
+    close: (id: string) => void;
+    loadOlder: (id: string) => Promise<void>;
+    send: (id: string, text: string) => Promise<void>;
+    retry: (id: string, messageId: string) => Promise<void>;
+    retryLoad: (id: string) => Promise<void>;
+    receive: (message: ChatMessage) => void;
+    setDraft: (id: string, text: string) => void;
+    setQuery: (text: string) => void;
+    /**
+     * Fires after an action outcome, so a component can mirror it as an emit.
+     * Returns an unsubscribe function.
+     */
+    onEvent: (listener: (event: ChatDockEvent) => void) => () => void;
+};
+export type ChatDockEvent = {
+    type: 'open';
+    id: string;
+} | {
+    type: 'close';
+    id: string;
+} | {
+    type: 'send';
+    message: ChatMessage;
+} | {
+    type: 'receive';
+    message: ChatMessage;
+} | {
+    type: 'error';
+    kind: ChatDockErrorKind;
+    id?: string;
+    error: unknown;
+};
+export type KMessengerProps = {
+    /** The component creates its own store. Exactly one of `loaders` or `store`. */
+    loaders?: ChatDockLoaders;
+    /** A store created with `useChatDock` elsewhere and shared. */
+    store?: ChatDockStore;
+    minWindows?: number;
+    title?: string;
+    placeholder?: string;
+    /** Passed to `useChatDock` when the component creates the store. */
+    evictOnClose?: boolean;
+    /**
+     * Passed to every window's `KChat`: stacks message actions under the bubble.
+     * Defaults to `true` — a dock window is too narrow to spare the width beside
+     * each bubble. Pass `false` to put them back at the side.
+     */
+    actionsBottom?: boolean;
+    /**
+     * Called for each message with the one before it. Return a label to render
+     * a divider above that message, or `undefined` for none. `previous` is
+     * `undefined` for the first message in the list.
+     *
+     * A boundary hook, not a date hook: an app tracking its own unread boundary
+     * returns "Unread messages" there and a day label elsewhere.
+     *
+     * Called for every message on every render, so compare pre-computed day
+     * keys here rather than parsing and formatting inside the callback.
+     */
+    dateLabel?: (message: ChatMessage, previous?: ChatMessage) => string | undefined;
+    /**
+     * Return a label to render this message as a `KChatNotice` instead of a
+     * `KChatMessage`. `undefined` renders it as a normal bubble.
+     *
+     * For an event that arrives in the same message stream as ordinary
+     * messages and is distinguished per message — "You left the meeting room",
+     * "Call ended at 01:48 PM".
+     *
+     * A notice renders no bubble, no sender side, no time and no actions row,
+     * and so no retry control either: a message carrying both `failed` and a
+     * notice label loses the way to retry it. Return `undefined` for a message
+     * still in flight. `dateLabel` still applies above a notice, so a day
+     * divider can precede one.
+     *
+     * Called for every message on every render, like `dateLabel` — read a
+     * pre-computed field here rather than deriving one inside the callback.
+     */
+    noticeLabel?: (message: ChatMessage) => string | undefined;
+};
+export type KMessengerEmits = {
+    open: [id: string];
+    close: [id: string];
+    send: [message: ChatMessage];
+    receive: [message: ChatMessage];
+    error: [kind: ChatDockErrorKind, id: string | undefined, error: unknown];
+};
+export type KMessengerSlots = {
+    /** Inside the avatar circle of a head and a panel row. */
+    avatar?(props: {
+        conversation: ChatConversation;
+    }): any;
+    /**
+     * The window header's action area, before the minimize and close controls.
+     * `window-` prefixed because an unprefixed `title` would read as the dock's
+     * own title, which is already a prop, and `actions` would collide with the
+     * panel's.
+     */
+    'window-actions'?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** The window header's title text. */
+    'window-title'?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** Inside a railed head's avatar circle. Falls back to `avatar`. */
+    head?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** Inside a `+N` popover row's avatar. Falls back to `avatar`. */
+    row?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** The panel header's action area, between the title and close. */
+    'panel-actions'?(): any;
+    /** The whole panel row. */
+    item?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** One message bubble's content. */
+    message?(props: {
+        message: ChatMessage;
+        conversation: ChatConversation;
+    }): any;
+    /**
+     * The hover row beside a message's bubble — put a `KChatMessageActions`
+     * here. `message-` prefixed to match `window-actions` and `panel-actions`,
+     * which are the two headers rather than a message.
+     *
+     * Forwarded only when you pass it, so `KChatMessage`'s own empty actions
+     * rendering is unchanged otherwise. Not rendered for a message that
+     * `noticeLabel` turned into a notice.
+     */
+    'message-actions'?(props: {
+        message: ChatMessage;
+        conversation: ChatConversation;
+    }): any;
+    /** The window footer. */
+    composer?(props: {
+        conversation: ChatConversation;
+        draft: string;
+        send: (text: string) => void;
+        setDraft: (text: string) => void;
+    }): any;
+    /** Window body while the first page loads. */
+    loading?(props: {
+        conversation: ChatConversation;
+    }): any;
+    /**
+     * The list row shown while an older page loads. Rendered inside the
+     * message `<ul>`, so its root must be an `<li>`.
+     */
+    'loading-older'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    /** Window body when the first page failed. */
+    error?(props: {
+        conversation: ChatConversation;
+        error: unknown;
+        retry: () => void;
+    }): any;
+    /** Panel text when the filter matches nothing. */
+    empty?(): any;
+    launcher?(): any;
+    /**
+     * Replaces the rendered divider while keeping `dateLabel`'s positioning.
+     * Whatever you render must be an `<li>`: it is a direct child of the
+     * message list's `<ul>`.
+     */
+    divider?(props: {
+        label: string;
+        message: ChatMessage;
+        previous?: ChatMessage;
+    }): any;
+    /**
+     * Replaces the rendered notice while keeping `noticeLabel`'s decision.
+     * Whatever you render must be an `<li>`: it is a direct child of the
+     * message list's `<ul>`.
+     */
+    notice?(props: {
+        label: string;
+        message: ChatMessage;
+    }): any;
+};