@knitify/vue 0.0.8 → 1.0.0

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;
+    maxRows: number;
+    placeholder: string;
+    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,50 @@
+export type KChatProps = {
+    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;
+};
+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/Checkbox/KCheckbox.vue.d.ts

@@ -0,0 +1,20 @@
+import type { KCheckboxModel, KCheckboxProps, KCheckboxSlots } from './types';
+type __VLS_Props = KCheckboxProps;
+type __VLS_Slots = KCheckboxSlots;
+type __VLS_ModelProps = {
+    modelValue?: KCheckboxModel;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: KCheckboxModel) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: KCheckboxModel) => 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/Checkbox/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `boolean` for a standalone box; an array for a group, where `value` is the
+ * entry added and removed as the box is toggled.
+ *
+ * Core ships no `--error` modifier — the one in its docs helper was removed —
+ * so there is deliberately no `error` prop here.
+ */
+export type KCheckboxModel = boolean | unknown[];
+export type KCheckboxProps = {
+    disabled?: boolean;
+    /**
+     * Partially-selected, for a "select all" parent. This is a DOM property
+     * rather than an attribute, so it is written to the input imperatively.
+     */
+    indeterminate?: boolean;
+    /** Text beside the box. The default slot overrides it; omit both for a bare box. */
+    label?: string;
+    /** The entry this box contributes when the model is an array. */
+    value?: unknown;
+};
+export type KCheckboxSlots = {
+    default?(): any;
+};

package/dist/types/components/Collapse/KCollapse.vue.d.ts

@@ -0,0 +1,32 @@
+import type { KCollapseProps, KCollapseSlots } from './types';
+type __VLS_Props = KCollapseProps;
+type __VLS_Slots = KCollapseSlots;
+type __VLS_ModelProps = {
+    'expanded'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    toggle: () => void;
+    expand: () => boolean;
+    collapse: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    collapse: () => any;
+    collapsed: () => any;
+    expand: () => any;
+    expanded: () => any;
+    "update:expanded": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onCollapse?: (() => any) | undefined;
+    onCollapsed?: (() => any) | undefined;
+    onExpand?: (() => any) | undefined;
+    onExpanded?: (() => any) | undefined;
+    "onUpdate:expanded"?: ((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/Collapse/types.d.ts

@@ -0,0 +1,32 @@
+export type KCollapseDirection = 'left' | 'right';
+export type KCollapseProps = {
+    /**
+     * Which edge a horizontal collapse clips from. `right` clips from the right;
+     * `left` pins the content to the right edge, which is what a right-hand
+     * sidebar wants.
+     */
+    direction?: KCollapseDirection;
+    /** Collapse along the inline axis rather than the block one. */
+    horizontal?: boolean;
+    /** Element to render as. */
+    tag?: string;
+};
+/** Mirrors core's four `kt.collapse*` events. None carries a payload. */
+export type KCollapseEmits = {
+    collapse: [];
+    collapsed: [];
+    expand: [];
+    expanded: [];
+};
+export type KCollapseSlots = {
+    /** The panel that opens and closes. */
+    default?(): any;
+    /**
+     * Anything here sits outside the collapsing region. A
+     * `data-kt-collapse-toggle` element inside it is driven by core directly.
+     */
+    toggle?(props: {
+        toggle: () => void;
+        expanded: boolean;
+    }): any;
+};

package/dist/types/components/Collapse/useCollapseSync.d.ts

@@ -0,0 +1,29 @@
+import { type Ref, type ShallowRef } from 'vue';
+export type CollapseSyncOptions = {
+    direction?: () => 'left' | 'right';
+    /** The `[data-kt-collapse]` root. */
+    element: Readonly<ShallowRef<HTMLElement | null>>;
+    expanded: Ref<boolean>;
+    horizontal?: () => boolean;
+    onEvent?: (name: 'collapse' | 'collapsed' | 'expand' | 'expanded') => void;
+};
+/**
+ * Two-way binding between a `v-model` and core's Collapse module.
+ *
+ * `data-kt-collapse` stays on the element, so core's delegated toggle keeps
+ * working — including `data-kt-collapse-group`, where opening one pane closes
+ * its siblings through core rather than through Vue. Each sibling hears its own
+ * `kt.collapse` and updates its own model, so grouping needs no coordination
+ * here.
+ *
+ * The guard is `moduleExpanded` — which way the module is actually going —
+ * rather than a flag set around the model write. Vue 3.5 batches reactive
+ * effects, so even a `sync` watcher runs at the end of the enclosing batch,
+ * by which time a flag would already have been cleared and the watcher would
+ * re-enter the module and dispatch a second event.
+ */
+export declare function useCollapseSync({ direction, element, expanded, horizontal, onEvent, }: CollapseSyncOptions): {
+    collapse: () => void;
+    expand: () => void;
+    toggle: () => void;
+};

package/dist/types/components/Drawer/KDrawer.vue.d.ts

@@ -0,0 +1,34 @@
+import type { KDrawerProps, KDrawerSlots } from './types';
+type __VLS_Props = KDrawerProps;
+type __VLS_Slots = KDrawerSlots;
+declare function hide(): void;
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    show: () => boolean;
+    hide: typeof hide;
+    toggle: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+} & {
+    hidden: () => any;
+    hide: () => any;
+    show: () => any;
+    shown: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onHidden?: (() => any) | undefined;
+    onHide?: (() => any) | undefined;
+    onShow?: (() => any) | undefined;
+    onShown?: (() => any) | undefined;
+    "onUpdate:open"?: ((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/Drawer/types.d.ts

@@ -0,0 +1,54 @@
+import { ClassValue } from 'vue';
+export type KDrawerEdge = 'left' | 'right';
+/** `md` is core's default and emits no modifier class. */
+export type KDrawerSize = 'sm' | 'md' | 'lg';
+export type KDrawerProps = {
+    bodyClass?: ClassValue;
+    /** Renders the header's dismiss button. */
+    closable?: boolean;
+    /**
+     * Confine the drawer to its nearest positioned ancestor rather than the
+     * viewport. Implies `teleport: false` — moving it to `<body>` would defeat
+     * the containment.
+     */
+    contained?: boolean;
+    /** Which side it slides in from. */
+    edge?: KDrawerEdge;
+    /**
+     * Focus the first focusable element on open. Core rebuilds its own instance
+     * for `data-kt-drawer-toggle` clicks and does not read this off the DOM, so
+     * it only applies when Vue opens the drawer.
+     */
+    focus?: boolean;
+    footerClass?: ClassValue;
+    headerClass?: ClassValue;
+    /** Defaults to a generated id. Point `data-kt-drawer-toggle` at this. */
+    id?: string;
+    /**
+     * Close on Escape. Honoured on both paths — the wrapper intercepts the key
+     * in the capture phase to hold core's own handler off.
+     */
+    keyboard?: boolean;
+    /** Leaves the page behind clickable and drops the scrim. */
+    noBackdrop?: boolean;
+    panelClass?: ClassValue;
+    size?: KDrawerSize;
+    /** Ignore backdrop clicks, leaving an explicit dismiss the only way out. */
+    staticBackdrop?: boolean;
+    /** Defaults to true, except for a `contained` drawer. */
+    teleport?: boolean;
+    title?: string;
+};
+export type KDrawerEmits = {
+    (event: 'hide'): void;
+    (event: 'hidden'): void;
+    (event: 'show'): void;
+    (event: 'shown'): void;
+};
+export type KDrawerSlots = {
+    close?(): any;
+    default?(): any;
+    footer?(): any;
+    header?(): any;
+    title?(): any;
+};

package/dist/types/components/Dropdown/KDropdown.vue.d.ts

@@ -0,0 +1,28 @@
+import type { KDropdownProps, KDropdownSlots } from './types';
+type __VLS_Props = KDropdownProps;
+type __VLS_Slots = KDropdownSlots;
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    toggle: () => void;
+    show: () => boolean;
+    hide: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    hidden: () => any;
+    shown: () => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onHidden?: (() => any) | undefined;
+    onShown?: (() => any) | undefined;
+    "onUpdate:open"?: ((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/Dropdown/KDropdownItem.vue.d.ts

@@ -0,0 +1,13 @@
+import type { KDropdownItemProps } from './types';
+type __VLS_Slots = {
+    default?(): any;
+};
+declare const __VLS_base: import("vue").DefineComponent<KDropdownItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KDropdownItemProps> & 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/Dropdown/KDropdownMenu.vue.d.ts

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

@@ -0,0 +1,34 @@
+import { ClassValue } from 'vue';
+import type { KPlacement } from '../Popover/types';
+export type KDropdownProps = {
+    /** Renders the menu inline in the flow instead of floating. */
+    inline?: boolean;
+    menuClass?: ClassValue;
+    placement?: KPlacement;
+    toggleClass?: ClassValue;
+};
+export type KDropdownItemProps = {
+    active?: boolean;
+    /**
+     * Opens a submenu. Put a `KDropdownMenu` with `submenu` inside the item's
+     * default slot.
+     */
+    parent?: boolean;
+    /** Renders a non-interactive line of text rather than a menu row. */
+    text?: boolean;
+};
+export type KDropdownMenuProps = {
+    /** Nested menu, revealed by its parent item. */
+    submenu?: boolean;
+};
+export type KDropdownEmits = {
+    hidden: [];
+    shown: [];
+};
+export type KDropdownSlots = {
+    default?(): any;
+    toggle?(props: {
+        open: boolean;
+        toggle: () => void;
+    }): any;
+};

package/dist/types/components/FileTree/KFileTree.vue.d.ts

@@ -0,0 +1,34 @@
+import type { KFileTreeProps, KFileTreeSlots } from './types';
+type __VLS_Props = KFileTreeProps;
+type __VLS_Slots = KFileTreeSlots;
+type __VLS_ModelProps = {
+    'selected'?: string | null;
+    'expanded'?: string[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    collapseAll: () => void | undefined;
+    expandAll: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (id: string) => any;
+    collapse: (id: string) => any;
+    expand: (id: string) => any;
+    load: (id: string) => any;
+    "update:expanded": (value: string[]) => any;
+    "update:selected": (value: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((id: string) => any) | undefined;
+    onCollapse?: ((id: string) => any) | undefined;
+    onExpand?: ((id: string) => any) | undefined;
+    onLoad?: ((id: string) => any) | undefined;
+    "onUpdate:expanded"?: ((value: string[]) => any) | undefined;
+    "onUpdate:selected"?: ((value: string | 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/FileTree/KFileTreeNode.vue.d.ts

@@ -0,0 +1,20 @@
+import type { KFileTreeNode } from './types';
+type __VLS_Props = {
+    caretIcon?: string;
+    node: KFileTreeNode;
+    tabbable?: boolean;
+};
+type __VLS_Slots = {
+    label?(props: {
+        node: KFileTreeNode;
+    }): any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & 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/FileTree/types.d.ts

@@ -0,0 +1,39 @@
+export type KFileTreeActivation = 'row' | 'caret';
+export type KFileTreeNode = {
+    /** Branch contents. An empty array still makes the node a branch. */
+    children?: KFileTreeNode[];
+    expanded?: boolean;
+    /** Sprite href for the leading glyph. */
+    icon?: string;
+    /**
+     * Stable identity, used by `v-model:selected` and `v-model:expanded`.
+     * Falls back to the label, so give siblings distinct labels or supply ids.
+     */
+    id?: string;
+    label: string;
+    /**
+     * A branch whose children arrive later. Listen for `load` and push them into
+     * the node's `children`.
+     */
+    lazy?: boolean;
+};
+export type KFileTreeProps = {
+    /** Whether the whole row toggles a branch, or only its caret. */
+    activation?: KFileTreeActivation;
+    /** Sprite href for a branch's caret. */
+    caretIcon?: string;
+    nodes?: KFileTreeNode[];
+};
+export type KFileTreeEmits = {
+    collapse: [id: string];
+    expand: [id: string];
+    /** A lazy branch was opened and needs its children. */
+    load: [id: string];
+    select: [id: string];
+};
+export type KFileTreeSlots = {
+    /** Replaces a row's default icon-and-label content. */
+    label?(props: {
+        node: KFileTreeNode;
+    }): any;
+};

package/dist/types/components/Grid/KGrid.vue.d.ts

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

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

@@ -0,0 +1,19 @@
+import type { KGridSlots } from './types';
+type __VLS_Slots = KGridSlots;
+declare const __VLS_base: import("vue").DefineComponent<{
+    gap?: import("./types").KGridGap;
+    colGap?: import("./types").KGridGap;
+    rowGap?: import("./types").KGridGap;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    gap?: import("./types").KGridGap;
+    colGap?: import("./types").KGridGap;
+    rowGap?: import("./types").KGridGap;
+}> & 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/Grid/types.d.ts

@@ -0,0 +1,41 @@
+/** Core emits no `md` class — `space.md` is the default gap. */
+export type KGridGap = 0 | 'xs' | 'sm' | 'lg' | 'xl' | '2xl';
+export type KGridAlign = 'start' | 'center' | 'end' | 'stretch';
+export type KGridBreakpoint = 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+/** A bare number, or a value per breakpoint. `base` is the unprefixed class. */
+export type KGridResponsive = number | ({
+    base?: number;
+} & Partial<Record<KGridBreakpoint, number>>);
+type GapProps = {
+    /** Both axes at once. `rowGap` and `colGap` override it per axis. */
+    gap?: KGridGap;
+    colGap?: KGridGap;
+    rowGap?: KGridGap;
+};
+export type KGridProps = GapProps & {
+    align?: KGridAlign;
+    /**
+     * Equal columns. 1–12 use core's `is-cols-{n}`; anything else falls back to
+     * setting `--kt-grid-columns` inline, which is core's documented escape
+     * hatch for counts outside that range.
+     */
+    cols?: number;
+    justify?: KGridAlign;
+    /** Sets `--kt-grid-rows`. */
+    rows?: number;
+};
+export type KGridRowProps = GapProps;
+export type KGridColumnProps = {
+    alignSelf?: KGridAlign;
+    justifySelf?: KGridAlign;
+    /** Row span. Core ships 2–6 only. */
+    row?: number;
+    /** Where the column begins. Column numbering starts at 1. */
+    start?: KGridResponsive;
+    /** How many of the 12 columns to span. */
+    span?: KGridResponsive;
+};
+export type KGridSlots = {
+    default?(): any;
+};
+export {};

package/dist/types/components/Grid/useGrid.d.ts

@@ -0,0 +1,8 @@
+import type { KGridGap, KGridResponsive } from './types';
+/**
+ * Expands a responsive prop into core's class list. `base` is unprefixed and
+ * every breakpoint carries its infix, so `{ base: 12, md: 6 }` on `column`
+ * becomes `is-column-12 is-column-md-6`.
+ */
+export declare function responsiveClasses(prefix: string, value: KGridResponsive | undefined): string[];
+export declare function gapClasses(gap?: KGridGap, rowGap?: KGridGap, colGap?: KGridGap): (string | false)[];

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

@@ -1,3 +1,3 @@
 export type KIconProps = {
-    href: string;
+    href?: string;
 };

package/dist/types/components/Input/KInput.vue.d.ts

@@ -0,0 +1,22 @@
+import type { KInputProps, KInputSlots } from './types';
+type __VLS_Props = KInputProps;
+type __VLS_Slots = KInputSlots;
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    field: Readonly<import("vue").ShallowRef<HTMLTextAreaElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: 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;
+    };
+};