@knitify/vue 0.0.8 → 1.0.0

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

@@ -0,0 +1,21 @@
+export type KInputSlots = {
+    prefix?(): any;
+    suffix?(): any;
+};
+export type KInputProps = {
+    addonBordered?: boolean;
+    /** Implies `textarea`. Growth is core's `Input.ts`, so it needs `Knitify.init()`. */
+    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;
+} & {
+    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/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, {
+    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/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,35 @@
+import { type Ref, type ShallowRef } from 'vue';
+export type OverlayModule = {
+    hide(): void;
+    show(): void;
+};
+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>;
+};
+/**
+ * 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, onEvent, open, }: OverlaySyncOptions<T>): {
+    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;
+    };
+};

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

@@ -0,0 +1,19 @@
+export type KProgressShape = 'linear' | 'circular' | 'semiCircular';
+/** `md` is core's default and emits no modifier class. */
+export type KProgressSize = 'sm' | 'md' | 'lg';
+export type KProgressProps = {
+    /** Overrides the default `{percent}%` readout. The `label` slot wins over both. */
+    label?: string;
+    /** Upper bound for `value`. Core's fill runs on a 0–100 scale regardless. */
+    max?: number;
+    /** Fully rounds the track and fill. Linear only. */
+    rounded?: boolean;
+    shape?: KProgressShape;
+    /** Linear only — the circular shapes take their size from the container. */
+    size?: KProgressSize;
+    /** Clamped to 0…`max`. */
+    value?: number;
+};
+export type KProgressSlots = {
+    label?(): any;
+};

package/dist/types/components/Radio/KRadio.vue.d.ts

@@ -0,0 +1,20 @@
+import type { KRadioProps, KRadioSlots } from './types';
+type __VLS_Props = KRadioProps;
+type __VLS_Slots = KRadioSlots;
+type __VLS_ModelProps = {
+    modelValue?: unknown;
+};
+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: unknown) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: unknown) => 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/Radio/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Core ships no `--error` modifier — the one in its docs helper was removed —
+ * so there is deliberately no `error` prop here.
+ */
+export type KRadioProps = {
+    disabled?: boolean;
+    /** Text beside the dot. The default slot overrides it. */
+    label?: string;
+    /**
+     * Groups radios for keyboard navigation. Selection is driven by the shared
+     * `v-model`, so this is only needed when the group must also work natively —
+     * inside an uncontrolled form, say.
+     */
+    name?: string;
+    /** What the shared model is set to when this radio is picked. */
+    value?: unknown;
+};
+export type KRadioSlots = {
+    default?(): any;
+};

package/dist/types/components/Select/KSelect.vue.d.ts

@@ -0,0 +1,22 @@
+import type { KSelectProps, KSelectSlots } from './types';
+type __VLS_Props = KSelectProps;
+type __VLS_Slots = KSelectSlots;
+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, {
+    change: (value: string) => any;
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((value: string) => any) | undefined;
+    "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;
+    };
+};

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

@@ -0,0 +1,30 @@
+import { ClassValue } from 'vue';
+export type KSelectOption = {
+    label: string;
+    value: string;
+};
+export type KSelectProps = {
+    disabled?: boolean;
+    /** Sprite href for the caret. */
+    icon?: string;
+    /** Renders the control inline rather than filling its container. */
+    inline?: boolean;
+    menuClass?: ClassValue;
+    /**
+     * A bare string is used as both value and label.
+     *
+     * Values are read back off a DOM attribute, so the model is always a string —
+     * numbers and objects are not preserved.
+     */
+    options?: (KSelectOption | string)[];
+    /** Shown until something is chosen. */
+    placeholder?: string;
+    toggleClass?: ClassValue;
+};
+export type KSelectEmits = {
+    change: [value: string];
+};
+export type KSelectSlots = {
+    /** Replaces the generated items. Give each one `data-kt-select-item`. */
+    default?(): any;
+};

package/dist/types/components/Table/KTable.vue.d.ts

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

@@ -0,0 +1,16 @@
+/** `md` is core's default and emits no modifier class. */
+export type KTableSize = 'md' | 'lg' | 'xl';
+/**
+ * A styling wrapper over a real `<table>`, deliberately not a data grid. Core's
+ * Table is pure CSS, so the markup — and with it sorting, selection, and
+ * colspans — stays yours.
+ */
+export type KTableProps = {
+    borderless?: boolean;
+    hoverable?: boolean;
+    size?: KTableSize;
+    striped?: boolean;
+};
+export type KTableSlots = {
+    default?(): any;
+};

package/dist/types/components/Tabs/KTab.vue.d.ts

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

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

@@ -0,0 +1,25 @@
+import type { KTabsProps, KTabsSlots } from './types';
+type __VLS_Props = KTabsProps;
+type __VLS_Slots = KTabsSlots;
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    show: (name: string) => string;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+} & {
+    shown: (name: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+    onShown?: ((name: 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/Tabs/types.d.ts

@@ -0,0 +1,35 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+export type KTabsVariant = 'pills' | 'underline';
+export type KTabsProps = {
+    /** Names the tablist. */
+    ariaLabel?: string;
+    variant?: KTabsVariant;
+};
+export type KTabProps = {
+    disabled?: boolean;
+    /** Matches this tab to its panel, and is what `v-model` holds. */
+    name: string;
+};
+export type KTabPanelProps = {
+    /** Matches this panel to its tab. */
+    name: string;
+};
+export type KTabsEmits = {
+    (event: 'shown', name: string): void;
+};
+export type KTabsSlots = {
+    /** The panels. */
+    default?(): any;
+    /** The tab buttons, rendered into the tablist. */
+    tabs?(): any;
+};
+export type KTabsContext = {
+    active: ComputedRef<string | undefined>;
+    /**
+     * Core resolves a panel with `querySelector('#' + target)` without escaping,
+     * so the id is restricted to characters that are safe unquoted. Two names
+     * differing only in punctuation therefore collapse to the same id.
+     */
+    panelId: (name: string) => string;
+};
+export declare const tabsKey: InjectionKey<KTabsContext>;

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

@@ -0,0 +1,20 @@
+export type KToastPosition = 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export type KToastOptions = {
+    description?: string;
+    /** Milliseconds before it closes itself. */
+    duration?: number;
+    /**
+     * Leading glyph, as a raw **HTML string** — core assigns it with `innerHTML`,
+     * not as a sprite href. Never pass user-supplied content here.
+     */
+    icon?: string;
+    position?: KToastPosition;
+    title: string;
+};
+/** Defaults applied to every toast raised through the returned helper. */
+export type KToastDefaults = Omit<KToastOptions, 'title'>;
+export type KToastHandle = {
+    close(): void;
+    pause(): void;
+    resume(): void;
+};

package/dist/types/components/Toast/useToast.d.ts

@@ -0,0 +1,20 @@
+import type { KToastDefaults, KToastHandle, KToastOptions, KToastPosition } from './types';
+/**
+ * Toasts have no component because core's Toast has no markup to wrap:
+ * `new Toast({ title })` builds its own element, mounts it into a container it
+ * manages, and runs its own stacking and timers. A `<KToast>` would mean
+ * reimplementing that in Vue and letting the two drift apart.
+ *
+ * ```ts
+ * const toast = useToast({ position: 'bottom-right' })
+ * toast.show({ title: 'Saved', description: 'Your changes are live.' })
+ * ```
+ *
+ * Nothing here is reactive or tied to a component instance, so it can be called
+ * from a setup function, an event handler, or a plain module.
+ */
+export declare function useToast(defaults?: KToastDefaults): {
+    /** Dismisses every toast, or only those in one corner. */
+    closeAll(position?: KToastPosition): void;
+    show(options: KToastOptions): KToastHandle;
+};

package/dist/types/components/Toggle/KToggle.vue.d.ts

@@ -0,0 +1,20 @@
+import type { KToggleProps, KToggleSlots } from './types';
+type __VLS_Props = KToggleProps;
+type __VLS_Slots = KToggleSlots;
+type __VLS_ModelProps = {
+    modelValue?: boolean;
+};
+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: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((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/Toggle/types.d.ts

@@ -0,0 +1,8 @@
+export type KToggleProps = {
+    disabled?: boolean;
+    /** Text beside the switch. The default slot overrides it. */
+    label?: string;
+};
+export type KToggleSlots = {
+    default?(): any;
+};