@knitify/vue 0.0.9 → 2.0.0

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, {
+    shown: () => any;
+    hidden: () => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onShown?: (() => any) | undefined;
+    onHidden?: (() => 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

@@ -5,7 +5,9 @@ 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, {
+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;

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

@@ -3,11 +3,19 @@ export type KInputSlots = {
     suffix?(): any;
 };
 export type KInputProps = {
+    addonBordered?: boolean;
+    /** Implies `textarea`. Growth is core's `Input.ts`, driven by this component. */
+    autosize?: boolean;
     disabled?: boolean;
     ghost?: boolean;
+    maxRows?: number;
     placeholder?: string;
+    readonly?: boolean;
     rounded?: boolean;
+    /** Fixed-height textareas only — an autosize field is always one row tall to start. */
+    rows?: number;
     sunken?: boolean;
+    textarea?: boolean;
     transparent?: boolean;
     type?: string;
 };

package/dist/types/components/MenuList/KMenuList.vue.d.ts

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

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

@@ -0,0 +1,20 @@
+import type { RouteLocationRaw } from 'vue-router';
+export type KMenuListProps = {
+    /** Names the navigation landmark wrapping the list. Omit for a plain list. */
+    ariaLabel?: string;
+};
+export type KMenuListItemProps = {
+    /**
+     * Marks the current row. With `to` and no explicit value, it follows the
+     * router's own active state.
+     */
+    active?: boolean;
+    /** Native `disabled` on a button; `is-disabled` + `aria-disabled` on a link. */
+    disabled?: boolean;
+    href?: string;
+    /** Router destination. Takes precedence over `href`. */
+    to?: RouteLocationRaw;
+};
+export type KMenuListSlots = {
+    default?(): any;
+};

package/dist/types/components/Modal/KModal.vue.d.ts

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

@@ -0,0 +1,57 @@
+import { ClassValue } from 'vue';
+export type KModalSize = 'sm' | 'md' | 'lg' | 'xl';
+export type KModalProps = {
+    bodyClass?: ClassValue;
+    /** Vertically centre the dialog rather than aligning it to the top. */
+    centered?: boolean;
+    /** Renders the header's dismiss button. */
+    closable?: boolean;
+    containerClass?: ClassValue;
+    dialogClass?: ClassValue;
+    dialogLabel?: string;
+    /**
+     * Focus the first focusable element on open. Core rebuilds its own instance
+     * for `data-kt-modal-toggle` clicks and does not read this off the DOM, so it
+     * only applies when Vue opens the modal.
+     */
+    focus?: boolean;
+    footerClass?: ClassValue;
+    fullscreen?: boolean;
+    headerClass?: ClassValue;
+    /** Defaults to a generated id. Point `data-kt-modal-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.
+     *
+     * With two modals open at once, core closes the first `is-active` element in
+     * document order rather than the topmost, so Escape can reach the wrong one.
+     */
+    keyboard?: boolean;
+    mainClass?: ClassValue;
+    scrollable?: boolean;
+    sidebarClass?: ClassValue;
+    size?: KModalSize;
+    /** Ignore backdrop clicks, leaving an explicit dismiss the only way out. */
+    staticBackdrop?: boolean;
+    title?: string;
+    /**
+     * Render into `document.body`. On by default: the modal is `position: fixed`,
+     * which a transformed or filtered ancestor would otherwise contain.
+     */
+    teleport?: boolean;
+};
+export type KModalEmits = {
+    (event: 'hide'): void;
+    (event: 'hidden'): void;
+    (event: 'show'): void;
+    (event: 'shown'): void;
+};
+export type KModalSlots = {
+    close?(): any;
+    default?(): any;
+    footer?(): any;
+    header?(): any;
+    sidebar?(): any;
+    title?(): any;
+};

package/dist/types/components/NotificationList/KNotificationList.vue.d.ts

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

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

@@ -0,0 +1,36 @@
+export type KNotificationListProps = {
+    /** Names the list for a screen reader. */
+    ariaLabel?: string;
+};
+export type KNotificationListItemProps = {
+    /**
+     * Forces the actions slot open. Core hides it until the row is hovered or
+     * focused within.
+     */
+    hovered?: boolean;
+    /** Relative timestamp. The `time` slot overrides it. */
+    time?: string;
+    /** Unread. Maps to core's `is-active`. */
+    unread?: boolean;
+    /**
+     * Visually hidden prefix announcing the unread state. Core's `is-active`
+     * changes only a fill and a bar, which conveys nothing to a screen reader
+     * or to anyone who cannot separate the brand tint from the base surface
+     * (WCAG 1.4.1). Core ships no visually-hidden utility, so this supplies one.
+     */
+    unreadLabel?: string;
+};
+export type KNotificationListSlots = {
+    default?(): any;
+};
+export type KNotificationListItemSlots = {
+    /**
+     * The overflow trigger. Core keeps this `display: none` until hover, which
+     * puts it outside the tab order — on a row with no inline link there is no
+     * keyboard path to it. Use `hovered` to keep it visible where that matters.
+     */
+    actions?(): any;
+    default?(): any;
+    media?(): any;
+    time?(): any;
+};

package/dist/types/components/Popover/KPopover.vue.d.ts

@@ -0,0 +1,28 @@
+import type { KPopoverProps, KPopoverSlots } from './types';
+type __VLS_Props = KPopoverProps;
+type __VLS_Slots = KPopoverSlots;
+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, {
+    shown: () => any;
+    hidden: () => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onShown?: (() => any) | undefined;
+    onHidden?: (() => 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/Popover/types.d.ts

@@ -0,0 +1,24 @@
+import { ClassValue } from 'vue';
+export type KPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+export type KPopoverProps = {
+    contentClass?: ClassValue;
+    placement?: KPlacement;
+    toggleClass?: ClassValue;
+};
+/**
+ * Core dispatches only the completion pair, so these fire once the overlay has
+ * finished opening or closing rather than when it begins.
+ */
+export type KPopoverEmits = {
+    hidden: [];
+    shown: [];
+};
+export type KPopoverSlots = {
+    /** The floating panel. */
+    default?(): any;
+    /** The element the panel is anchored to. */
+    toggle?(props: {
+        open: boolean;
+        toggle: () => void;
+    }): any;
+};

package/dist/types/components/Popover/useOverlaySync.d.ts

@@ -0,0 +1,49 @@
+import { type Ref, type ShallowRef } from 'vue';
+export type OverlayModule = {
+    hide(): void;
+    show(): void;
+    /** Core moves this to `<body>` while open, so it is outside the root. */
+    getContent?(): Element | null;
+};
+export type OverlaySyncOptions<T extends OverlayModule> = {
+    /** Builds the core module against the root element. */
+    create: (element: HTMLElement) => T;
+    /** The `[data-kt-*]` root. */
+    element: Readonly<ShallowRef<HTMLElement | null>>;
+    onEvent?: (name: 'shown' | 'hidden') => void;
+    open: Ref<boolean>;
+    /**
+     * Opening this overlay closes every other mounted overlay sharing the group.
+     * Replaces the sweep core's delegated toggle did by querying
+     * `[data-kt-popover].is-active` across the page.
+     */
+    group?: string;
+};
+/**
+ * Two-way binding between a `v-model` and core's Popover, Dropdown or Tooltip.
+ *
+ * Two things differ from the Modal flavour of this pattern:
+ *
+ * 1. These modules dispatch bare `kt.shown` / `kt.hidden` rather than a
+ *    namespaced `kt.modal.*`, and the events bubble. A tooltip inside a
+ *    dropdown would therefore reach the dropdown's listener, so every event is
+ *    checked against the element it was dispatched on.
+ * 2. There is no `show` / `hide` intent event — only the completion pair — so
+ *    the model updates when the overlay has opened or closed rather than when
+ *    it starts to.
+ *
+ * The guard is `moduleOpen`, which tracks the direction the module is heading,
+ * because Vue 3.5 batches reactive effects: a flag set around the model write
+ * would already be cleared by the time even a `sync` watcher ran.
+ */
+export declare function useOverlaySync<T extends OverlayModule>({ create, element, group, onEvent, open, }: OverlaySyncOptions<T>): {
+    /**
+     * The live core instance, for module-specific behaviour a wrapper binds
+     * itself — Dropdown's submenus, for instance. Undefined before the root
+     * element exists.
+     */
+    getInstance: () => T | undefined;
+    hide: () => void;
+    show: () => void;
+    toggle: () => void;
+};

package/dist/types/components/Progress/KProgress.vue.d.ts

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