@knitify/vue 2.0.0 → 2.2.0

package/dist/types/components/Alert/KAlert.vue.d.ts

@@ -1,6 +1,26 @@
-import type { KAlertProps, KAlertSlots } from './types';
+import type { KAlertSlots } from './types';
 type __VLS_Slots = KAlertSlots;
-declare const __VLS_base: import("vue").DefineComponent<KAlertProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KAlertProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<({
+    title?: string;
+} & {
+    banner?: false;
+    variant?: import("../..").Intent;
+}) | ({
+    title?: string;
+} & {
+    banner: true;
+    variant?: import("./types").KAlertBannerIntent;
+}), {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<({
+    title?: string;
+} & {
+    banner?: false;
+    variant?: import("../..").Intent;
+}) | ({
+    title?: string;
+} & {
+    banner: true;
+    variant?: import("./types").KAlertBannerIntent;
+})> & 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;

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

@@ -1,4 +1,6 @@
 import { Intent } from '../../types';
+/** The intents core gives a banner colour to. */
+export type KAlertBannerIntent = Extract<Intent, 'caution' | 'critical' | 'info'>;
 /**
  * Core ships no `--edged` modifier — the one in its docs helper does not exist
  * in the stylesheet — so there is deliberately no `edged` prop here.
@@ -6,12 +8,20 @@ import { Intent } from '../../types';
  * Anchors inside the message need `class="KAlert-link"` to pick up the alert's
  * text colour. That stays the consumer's job: the slot content is arbitrary,
  * so the wrapper has nothing to attach it to.
+ *
+ * `banner` narrows `variant` to the intents that have a banner colour.
  */
 export type KAlertProps = {
     /** Bold label above the message. The `title` slot overrides it. */
     title?: string;
+} & ({
+    banner?: false;
     variant?: Intent;
-};
+} | {
+    /** Full-width page banner: no border or radius, centered text. */
+    banner: true;
+    variant?: KAlertBannerIntent;
+});
 export type KAlertSlots = {
     default?(): any;
     title?(): any;

package/dist/types/components/ArticleList/KArticleList.vue.d.ts

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

@@ -0,0 +1,15 @@
+import type { KArticleListItemProps, KArticleListItemSlots } from './types';
+type __VLS_Slots = KArticleListItemSlots;
+declare const __VLS_base: import("vue").DefineComponent<KArticleListItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<KArticleListItemProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => 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/ArticleList/types.d.ts

@@ -0,0 +1,47 @@
+import type { RouteLocationRaw } from 'vue-router';
+export type KArticleListProps = {
+    /** Names the list for a screen reader. */
+    ariaLabel?: string;
+};
+export type KArticleListItemProps = {
+    /**
+     * Marks the article currently open. Maps to core's `is-active` plus
+     * `aria-current`, since the fill alone conveys nothing to a screen reader.
+     */
+    active?: boolean;
+    /** Publication date. The `date` slot overrides it. */
+    date?: string;
+    /** Native `disabled` on a button; `is-disabled` + `aria-disabled` on a link. */
+    disabled?: boolean;
+    /** Excerpt, clamped to three lines by core. The default slot overrides it. */
+    excerpt?: string;
+    /** Forces the hover fill and the actions slot open, for previews. */
+    hovered?: boolean;
+    href?: string;
+    /** Sprite id of the trailing chevron, shown when there is no actions slot. */
+    icon?: string;
+    /** Article title. The `title` slot overrides it. */
+    title?: string;
+    /** Router destination. Takes precedence over `href`. */
+    to?: RouteLocationRaw;
+};
+export type KArticleListItemEmits = {
+    click: [event: MouseEvent];
+};
+export type KArticleListSlots = {
+    default?(): any;
+};
+export type KArticleListItemSlots = {
+    /**
+     * The overflow trigger, typically a `KDropdown` around a meatball
+     * `KButton`. Replaces the chevron. Core fades it in on hover or focus, and
+     * keeps it shown while the dropdown is open. Not rendered on a disabled row.
+     */
+    actions?(): any;
+    date?(): any;
+    /** The excerpt. */
+    default?(): any;
+    /** The trailing chevron. Ignored when the actions slot is filled. */
+    icon?(): any;
+    title?(): any;
+};

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

@@ -19,7 +19,7 @@ export type KAvatarProps = {
      */
     colorKey?: string;
     /**
-     * Placeholder glyph, used when there is no `src`. `true` is core's `#user`;
+     * Placeholder glyph, used when there is no `src`. `true` is core's `#kt-user`;
      * a string is any other sprite href.
      */
     icon?: boolean | string;

package/dist/types/components/ButtonGroup/KButtonGroup.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KButtonGroupSlots } from './types';
+type __VLS_Slots = KButtonGroupSlots;
+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/ButtonGroup/types.d.ts

@@ -0,0 +1,7 @@
+export type KButtonGroupSlots = {
+    /**
+     * `KButton`s, or wrappers around one — a `KDropdown` whose toggle is a
+     * `KButton` makes a split button.
+     */
+    default?(): any;
+};

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

@@ -13,6 +13,8 @@ export type KCalendarProps = {
     maxDate?: Date;
     minDate?: Date;
     mode?: KCalendarMode;
+    /** Months shown side by side. Two suits range selection; defaults to `1`. */
+    months?: 1 | 2;
 };
 export type KCalendarEmits = {
     clear: [];

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

@@ -6,12 +6,12 @@ type __VLS_ModelProps = {
 };
 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;
+    stop: () => any;
     "update:modelValue": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onStop?: (() => any) | undefined;
     onSubmit?: ((value: string) => any) | undefined;
+    onStop?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
     disabled: boolean;

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

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

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

@@ -124,11 +124,25 @@ export type KChatPromptEmits = {
     stop: [];
     submit: [value: string];
 };
+/**
+ * `busy` is the chat's busy state; `disabled` is whether the send button is
+ * disabled (no draft, or the prompt itself disabled), for controls that
+ * should follow it.
+ */
+type KChatPromptSlotProps = {
+    busy: boolean;
+    disabled: boolean;
+};
 export type KChatPromptSlots = {
-    send?(props: {
-        busy: boolean;
-        disabled: boolean;
-    }): any;
+    send?(props: KChatPromptSlotProps): any;
+    /** Inside the field border, before the text (a `KInput` addon). */
+    prefix?(props: KChatPromptSlotProps): any;
+    /** Inside the field border, after the text (a `KInput` addon). */
+    suffix?(props: KChatPromptSlotProps): any;
+    /** Outside the field, before it. */
+    start?(props: KChatPromptSlotProps): any;
+    /** Outside the field, between it and the send button. */
+    end?(props: KChatPromptSlotProps): any;
 };
 export type KChatShimmerProps = {
     interval?: number;
@@ -138,3 +152,4 @@ export type KChatShimmerProps = {
 export type KChatShimmerSlots = {
     default?(): any;
 };
+export {};

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

@@ -21,17 +21,19 @@ declare const __VLS_base: import("vue").DefineComponent<KChatDockProps, {
     togglePanel: typeof togglePanel;
     refilter: typeof refilter;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    select: (id: string, opened: boolean) => any;
     search: (query: string) => any;
+    select: (id: string, opened: boolean) => any;
     reflow: () => any;
     launcher: () => any;
+    compose: () => 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;
+    onSelect?: ((id: string, opened: boolean) => any) | undefined;
     onReflow?: (() => any) | undefined;
     onLauncher?: (() => any) | undefined;
+    onCompose?: (() => any) | undefined;
     onPanel?: ((open: boolean) => any) | undefined;
     onActivate?: ((id: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -0,0 +1,28 @@
+import type { KChatNewWindowProps, KChatNewWindowSlots, KChatWindowState } from './types';
+type __VLS_Props = KChatNewWindowProps;
+type __VLS_Slots = KChatNewWindowSlots;
+type __VLS_ModelProps = {
+    'state'?: KChatWindowState;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    expand: () => void | undefined;
+    rail: () => void | undefined;
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    search: (query: string) => any;
+    "update:state": (value: KChatWindowState) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onSearch?: ((query: string) => 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

@@ -6,12 +6,18 @@ declare const __VLS_base: import("vue").DefineComponent<KMessengerProps, ChatDoc
     open: (id: string) => any;
     close: (id: string) => any;
     receive: (message: import("./messenger-types").ChatMessage) => any;
+    compose: () => any;
+    "new-chat-search": (query: string) => any;
+    "new-chat-close": () => 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;
+    onCompose?: (() => any) | undefined;
+    "onNew-chat-search"?: ((query: string) => any) | undefined;
+    "onNew-chat-close"?: (() => 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;

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

@@ -55,6 +55,12 @@ export type ChatDockLoaders = {
 export type ChatDockOptions = {
     /** Drop messages, cursor and draft when a window closes. Default `false`. */
     evictOnClose?: boolean;
+    /**
+     * Skip the list load the store otherwise starts on creation; nothing is
+     * fetched until `ensureConversations` (or `refreshConversations`) is
+     * called. `KMessenger` calls it when the panel first opens. Default `false`.
+     */
+    lazy?: boolean;
 };
 export type ChatWindowState = 'closed' | 'expanded' | 'railed';
 export type LoadState = 'idle' | 'loading' | 'loaded' | 'error';
@@ -82,6 +88,12 @@ export type ChatDockStore = {
     /** Whether a composer can be rendered at all. */
     canSend: boolean;
     refreshConversations: () => Promise<void>;
+    /**
+     * Loads the list only if it has not loaded yet: starts a load when idle or
+     * failed, joins the one in flight, and does nothing once loaded. Safe to
+     * call on every panel open.
+     */
+    ensureConversations: () => Promise<void>;
     open: (id: string) => Promise<void>;
     /**
      * Shows a window again without treating it as a user-initiated open: no
@@ -130,8 +142,19 @@ export type KMessengerProps = {
     minWindows?: number;
     title?: string;
     placeholder?: string;
+    /** The "New chat" window's title. Default `'New Chat'`. */
+    newChatTitle?: string;
+    /** The "New chat" people search placeholder. Default `'To: Search People'`. */
+    newChatPlaceholder?: string;
+    /** The "New chat" people search's accessible name. Default `'Search people'`. */
+    newChatSearchLabel?: string;
     /** Passed to `useChatDock` when the component creates the store. */
     evictOnClose?: boolean;
+    /**
+     * Passed to `useChatDock` when the component creates the store: the list
+     * loads when the panel first opens instead of on mount. Default `false`.
+     */
+    lazy?: 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
@@ -175,6 +198,12 @@ export type KMessengerEmits = {
     send: [message: ChatMessage];
     receive: [message: ChatMessage];
     error: [kind: ChatDockErrorKind, id: string | undefined, error: unknown];
+    /** The panel's write button was clicked; the "New chat" window is open. */
+    compose: [];
+    /** Each keystroke in the "New chat" window's people search. */
+    'new-chat-search': [query: string];
+    /** The "New chat" window was closed. */
+    'new-chat-close': [];
 };
 export type KMessengerSlots = {
     /** Inside the avatar circle of a head and a panel row. */
@@ -206,8 +235,16 @@ export type KMessengerSlots = {
         conversation: ChatConversation;
         entry: ChatEntry;
     }): any;
-    /** The panel header's action area, between the title and close. */
+    /** The panel header's action area, before the write, maximize and close. */
     'panel-actions'?(): any;
+    /**
+     * The "New chat" window's body, under its people search — e.g. a "Create
+     * New Group" link and suggested people. `close` dismisses the window, for
+     * once a person is picked.
+     */
+    'new-chat'?(props: {
+        close: () => void;
+    }): any;
     /** The whole panel row. */
     item?(props: {
         conversation: ChatConversation;
@@ -238,6 +275,24 @@ export type KMessengerSlots = {
         send: (text: string) => void;
         setDraft: (text: string) => void;
     }): any;
+    /**
+     * Extra controls on the default composer, scoped by conversation so one
+     * template serves every window: `prefix`/`suffix` inside the field border,
+     * `start`/`end` outside it (`end` sits before the send button). Ignored
+     * when `composer` replaces the whole footer.
+     */
+    'composer-prefix'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    'composer-suffix'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    'composer-start'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    'composer-end'?(props: {
+        conversation: ChatConversation;
+    }): any;
     /** Window body while the first page loads. */
     loading?(props: {
         conversation: ChatConversation;

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

@@ -11,6 +11,11 @@ export type KChatDockProps = {
 export type KChatDockEmits = {
     reflow: [];
     launcher: [];
+    /**
+     * The panel's write button was clicked. The dock mounts nothing itself —
+     * render a `KChatNewWindow` (or anything else) in response.
+     */
+    compose: [];
     /** After the panel opens or closes. */
     panel: [open: boolean];
     /** After each filter, including the reset when the panel closes. */
@@ -65,10 +70,33 @@ export type KChatWindowSlots = {
     default?(): any;
     /** A railed head's circle. Falls back to `avatar` when not given. */
     head?(): any;
+    /**
+     * A full-width row under the title and actions, inside the header — e.g.
+     * the people search of `KChatNewWindow`. Rendered only when passed.
+     */
+    search?(): any;
     /** The popover row's avatar. Falls back to `avatar` when not given. */
     row?(): any;
     title?(): any;
 };
+export type KChatNewWindowProps = {
+    /** Pairs the window with its rail head, as `KChatWindow`'s `id` does. */
+    id?: string;
+    title?: string;
+    /** People search placeholder. */
+    placeholder?: string;
+    /** People search's accessible name. Default `'Search people'`. */
+    searchLabel?: string;
+};
+export type KChatNewWindowEmits = {
+    /** On every keystroke in the people search. */
+    search: [query: string];
+    close: [];
+};
+export type KChatNewWindowSlots = {
+    /** The body under the search: e.g. a "Create New Group" link, suggestions. */
+    default?(): any;
+};
 export type KChatDockPanelProps = {
     /** Header text. */
     title?: string;
@@ -84,8 +112,8 @@ export type KChatDockPanelSlots = {
     /** `KChatDockItem`s. */
     default?(): any;
     /**
-     * Header controls, between the title and the close button — so close stays
-     * last in the DOM and in the tab order. Rendered only when passed.
+     * Header controls, between the title and the built-in write, maximize and
+     * close buttons — so close stays last in the DOM and in the tab order.
      *
      * Controls here bind their own handlers. Do not put
      * `data-kt-chat-dock-item` on anything in this slot: `KChatDock`'s root

package/dist/types/components/DataTable/KDataTable.vue.d.ts

@@ -0,0 +1,71 @@
+import type { KTableSize } from '../Table/types';
+import type { KDataTableActionLabels, KDataTableColumn, KDataTableEmits, KDataTableRowKey, KDataTableSettingsLabels, KDataTableSlots, KDataTableSortLabels, KDataTableSortRule } from './types';
+declare const __VLS_export: <T extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(Omit<import("../types.js").KTableProps, "size" | "striped"> & {
+        actionLabels?: Partial<KDataTableActionLabels>;
+        columns?: KDataTableColumn<T>[] | undefined;
+        emptyLabel?: string;
+        filterLabel?: string;
+        loading?: boolean;
+        maxHeight?: string;
+        nextLabel?: string;
+        pageSize?: number;
+        pinStart?: number;
+        prevLabel?: string;
+        rowKey?: string | ((row: T) => KDataTableRowKey) | undefined;
+        rows?: T[] | undefined;
+        searchPlaceholder?: string;
+        selectable?: boolean;
+        settingsLabel?: string;
+        settingsLabels?: Partial<KDataTableSettingsLabels>;
+        sortLabel?: string;
+        sortLabels?: Partial<KDataTableSortLabels>;
+        sortOptions?: import("../types.js").KSelectOption[];
+        total: number;
+    } & {
+        page?: number;
+        search?: string;
+        selected?: KDataTableRowKey[];
+        sort?: KDataTableSortRule[];
+        hiddenColumns?: string[];
+        size?: KTableSize;
+        striped?: boolean;
+    }) & {
+        onResize?: ((widths: number[]) => any) | undefined;
+        onAction?: ((action: string, row: T, column: {
+            key: string;
+            label: string;
+            resizable?: boolean;
+            sortable?: boolean;
+        } & {
+            type: "link";
+        } & {
+            to: (row: T) => import("vue-router").RouteLocationRaw;
+        }, payload?: unknown) => any) | undefined;
+        "onUpdate:page"?: ((value: number) => any) | undefined;
+        "onUpdate:hiddenColumns"?: ((value: string[]) => any) | undefined;
+        "onUpdate:size"?: ((value: KTableSize) => any) | undefined;
+        "onUpdate:striped"?: ((value: boolean) => any) | undefined;
+        "onUpdate:search"?: ((value: string) => any) | undefined;
+        "onUpdate:selected"?: ((value: KDataTableRowKey[]) => any) | undefined;
+        "onUpdate:sort"?: ((value: KDataTableSortRule[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        /** Hands every column back to automatic layout. */
+        reset: () => void | undefined;
+    }>) => void;
+    attrs: any;
+    slots: KDataTableSlots<T>;
+    emit: KDataTableEmits<T> & (((event: "update:page", value: number) => void) & ((event: "update:hiddenColumns", value: string[]) => void) & ((event: "update:size", value: KTableSize) => void) & ((event: "update:striped", value: boolean) => void) & ((event: "update:search", value: string) => void) & ((event: "update:selected", value: KDataTableRowKey[]) => void) & ((event: "update:sort", value: KDataTableSortRule[]) => void));
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/DataTable/KDataTableLinkCell.vue.d.ts

@@ -0,0 +1,21 @@
+import type { KDataTableCellComponentProps } from './types';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<KDataTableCellComponentProps<T, "link"> & {
+        onAction?: ((action: string, payload?: unknown) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "action", action: string, payload?: unknown) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/DataTable/KDataTableSettings.vue.d.ts

@@ -0,0 +1,32 @@
+import type { KTableSize } from '../Table/types';
+import type { KDataTableColumn, KDataTableSettingsLabels } from './types';
+type __VLS_Props = {
+    columns: KDataTableColumn[];
+    labels: KDataTableSettingsLabels;
+};
+type __VLS_Slots = {
+    default?(): any;
+};
+type __VLS_ModelProps = {
+    'hiddenColumns'?: string[];
+    'size'?: KTableSize;
+    'striped'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hiddenColumns": (value: string[]) => any;
+    "update:size": (value: KTableSize) => any;
+    "update:striped": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hiddenColumns"?: ((value: string[]) => any) | undefined;
+    "onUpdate:size"?: ((value: KTableSize) => any) | undefined;
+    "onUpdate:striped"?: ((value: boolean) => 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/DataTable/KDataTableSort.vue.d.ts

@@ -0,0 +1,17 @@
+import type { KSelectOption } from '../Select/types';
+import type { KDataTableSortLabels, KDataTableSortRule } from './types';
+type __VLS_Props = {
+    labels: KDataTableSortLabels;
+    options: KSelectOption[];
+};
+type __VLS_ModelProps = {
+    modelValue?: KDataTableSortRule[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: KDataTableSortRule[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: KDataTableSortRule[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/DataTable/columnTypes.d.ts

@@ -0,0 +1,19 @@
+import { type Component } from 'vue';
+import type { KDataTableColumnType } from './types';
+/**
+ * Makes `component` render the cells of every column whose `type` is `type`,
+ * in every KDataTable. Register before the app mounts — tables already on
+ * screen don't pick up a type registered later. Registering a name again
+ * replaces its component, built-in `link` included.
+ *
+ * Declare the type in `KDataTableColumnTypes` first; `type` only accepts the
+ * names declared there.
+ */
+export declare function registerColumnType(type: KDataTableColumnType, component: Component): void;
+/**
+ * The component registered for `type`. With none, its cells fall back to
+ * plain text, and the first lookup warns so a missing `registerColumnType`
+ * call is noticed. Not gated on a dev flag: the library is prebuilt, so its
+ * own build would decide that, not the consumer's.
+ */
+export declare function resolveColumnType(type: string): Component | undefined;

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

@@ -0,0 +1,9 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+import type { KDataTableActionLabels } from './types';
+/** The `link` column type's menu text when `actionLabels` leaves an entry out. */
+export declare const DEFAULT_ACTION_LABELS: KDataTableActionLabels;
+export interface DataTableContext {
+    /** The resolved menu text for `link` cells, defaults filled in. */
+    actionLabels: ComputedRef<KDataTableActionLabels>;
+}
+export declare const dataTableKey: InjectionKey<DataTableContext>;