@knitify/vue 0.0.9 → 2.0.0

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

@@ -0,0 +1,23 @@
+import type { RouteLocationRaw } from 'vue-router';
+export type KBreadcrumbProps = {
+    /** Names the navigation landmark. */
+    ariaLabel?: string;
+    /** Separator between crumbs. Core's default is a double angle quote. */
+    divider?: string;
+};
+export type KBreadcrumbItemProps = {
+    /**
+     * The current page. Renders as plain text rather than a link, and carries
+     * `aria-current="page"`.
+     *
+     * Note this maps to core's `KBreadcrumb-is-active`, not the `is-active`
+     * state class every other module uses.
+     */
+    active?: boolean;
+    href?: string;
+    /** Router destination. Takes precedence over `href`. */
+    to?: RouteLocationRaw;
+};
+export type KBreadcrumbSlots = {
+    default?(): any;
+};

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

@@ -1,16 +1,27 @@
 import type { RouteLocationRaw } from 'vue-router';
-import type { Variant } from '../../types';
+import type { Intent } from '../../types';
 export type KButtonType = 'button' | 'submit' | 'reset';
+export type KButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type KButtonProps = {
     disabled?: boolean;
     expanded?: boolean;
-    ghost?: boolean;
     href?: string;
-    outline?: boolean;
+    icon?: boolean;
+    iconCircular?: boolean;
+    minimal?: boolean;
     rounded?: boolean;
+    secondary?: boolean;
+    selected?: boolean;
+    size?: KButtonSize;
     to?: RouteLocationRaw;
     type?: KButtonType;
-    variant?: Variant;
+    utility?: boolean;
+    /**
+     * Semantic color. Core ships no `utilityWarning`, `minimalWarning` or
+     * `minimalAffirm` modifier, so those combinations render as the solid
+     * fill for that intent.
+     */
+    variant?: Intent;
 };
 export type KButtonSlots = {
     default?(): any;

package/dist/types/components/Calendar/KCalendar.vue.d.ts

@@ -0,0 +1,34 @@
+import type { KCalendarProps, KCalendarRange, KCalendarSlots } from './types';
+type __VLS_Props = KCalendarProps;
+type __VLS_Slots = KCalendarSlots;
+type __VLS_ModelProps = {
+    modelValue?: Date | null;
+    'range'?: KCalendarRange | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    clear: () => void | undefined;
+    navigateTo: (year: number, month: number) => void | undefined;
+    next: () => void | undefined;
+    prev: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    navigate: (year: number, month: number) => any;
+    clear: () => any;
+    rangestart: (date: Date) => any;
+    "update:modelValue": (value: Date | null) => any;
+    "update:range": (value: KCalendarRange | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onNavigate?: ((year: number, month: number) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onRangestart?: ((date: Date) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Date | null) => any) | undefined;
+    "onUpdate:range"?: ((value: KCalendarRange | null) => 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/Calendar/types.d.ts

@@ -0,0 +1,26 @@
+export type KCalendarMode = 'single' | 'range';
+export type KCalendarRange = {
+    end: Date;
+    start: Date;
+};
+export type KCalendarProps = {
+    /** Dates that cannot be picked. */
+    disabledDates?: Date[];
+    /** `0` is Sunday, `1` is Monday. */
+    firstDay?: 0 | 1;
+    /** BCP 47 tag driving the month and weekday names. */
+    locale?: string;
+    maxDate?: Date;
+    minDate?: Date;
+    mode?: KCalendarMode;
+};
+export type KCalendarEmits = {
+    clear: [];
+    navigate: [year: number, month: number];
+    rangestart: [date: Date];
+};
+/**
+ * No slots: core renders the whole calendar into its container with
+ * `innerHTML`, so anything Vue put inside would be wiped on the first paint.
+ */
+export type KCalendarSlots = Record<string, never>;

package/dist/types/components/Card/KCard.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KCardProps, KCardSlots } from './types';
+type __VLS_Slots = KCardSlots;
+declare const __VLS_base: import("vue").DefineComponent<KCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KCardProps> & 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/Card/types.d.ts

@@ -0,0 +1,26 @@
+import { ClassValue } from 'vue';
+export type KCardProps = {
+    /** Adds the accent bar. */
+    accented?: boolean;
+    bodyClass?: ClassValue;
+    /** Drops the border and the header and footer rules. */
+    borderless?: boolean;
+    footerClass?: ClassValue;
+    /** Removes the header and footer padding, so their content sits flush. */
+    flush?: boolean;
+    headerClass?: ClassValue;
+    /** Raises the card on hover. */
+    hoverable?: boolean;
+    /** Sits the card on a shadow rather than a border. */
+    lifted?: boolean;
+    /** Recesses the card into the surface behind it. */
+    sunken?: boolean;
+    /** Heading inside the header. The `title` slot overrides it. */
+    title?: string;
+};
+export type KCardSlots = {
+    default?(): any;
+    footer?(): any;
+    header?(): any;
+    title?(): any;
+};

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

@@ -0,0 +1,14 @@
+import type { KChatProps, KChatSlots } from './types';
+type __VLS_Slots = KChatSlots;
+declare function scrollToBottom(): void;
+declare const __VLS_base: import("vue").DefineComponent<KChatProps, {
+    scrollToBottom: typeof scrollToBottom;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KChatProps> & 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/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/KChatMessage.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KChatMessageProps, KChatMessageSlots } from './types';
+type __VLS_Slots = KChatMessageSlots;
+declare const __VLS_base: import("vue").DefineComponent<KChatMessageProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KChatMessageProps> & 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/KChatMessages.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KChatMessagesSlots } from './types';
+type __VLS_Slots = KChatMessagesSlots;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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

@@ -0,0 +1,30 @@
+import type { KChatPromptProps, KChatPromptSlots } from './types';
+type __VLS_Props = KChatPromptProps;
+type __VLS_Slots = KChatPromptSlots;
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    stop: () => any;
+    submit: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onStop?: (() => any) | undefined;
+    onSubmit?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    busy: boolean;
+    placeholder: string;
+    maxRows: number;
+    newlineOnEnter: boolean;
+}, {}, {}, {}, 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/KChatShimmer.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KChatShimmerProps, KChatShimmerSlots } from './types';
+type __VLS_Slots = KChatShimmerSlots;
+declare const __VLS_base: import("vue").DefineComponent<KChatShimmerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KChatShimmerProps> & 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/keys.d.ts

@@ -0,0 +1,2 @@
+import type { InjectionKey, Ref } from 'vue';
+export declare const chatBusyKey: InjectionKey<Ref<boolean>>;

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

@@ -0,0 +1,140 @@
+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;
+    height?: string;
+};
+export type KChatSlots = {
+    default?(): any;
+    footer?(): any;
+};
+export type KChatMessagesSlots = {
+    default?(): any;
+};
+export type KChatMessageProps = {
+    sender?: boolean;
+    time?: string;
+};
+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;
+    disabled?: boolean;
+    maxRows?: number;
+    /**
+     * Enter inserts a newline instead of sending. The button becomes the only
+     * send path, which is how core's plain-HTML prompt behaves.
+     */
+    newlineOnEnter?: boolean;
+    placeholder?: string;
+};
+export type KChatPromptEmits = {
+    stop: [];
+    submit: [value: string];
+};
+export type KChatPromptSlots = {
+    send?(props: {
+        busy: boolean;
+        disabled: boolean;
+    }): any;
+};
+export type KChatShimmerProps = {
+    interval?: number;
+    text?: string;
+    texts?: string[];
+};
+export type KChatShimmerSlots = {
+    default?(): any;
+};

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>;