@knitify/vue 1.0.0 → 2.1.0

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

@@ -0,0 +1,25 @@
+export type KSegmentedButtonsProps = {
+    /** Stretches across the container, splitting the width equally. */
+    block?: boolean;
+};
+export type KSegmentedButtonsSlots = {
+    default?(): any;
+};
+export type KSegmentedButtonProps = {
+    disabled?: boolean;
+    /** Sprite id of the icon before the label, e.g. `kt-preview`. */
+    icon?: string;
+    /** Segment text. The default slot overrides it. */
+    label?: string;
+    /**
+     * Groups segments 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 segment is picked. */
+    value?: unknown;
+};
+export type KSegmentedButtonSlots = {
+    default?(): any;
+};

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

@@ -7,9 +7,11 @@ 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, {
     change: (value: string) => any;
+    clear: () => any;
     "update:modelValue": (value: string | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onChange?: ((value: string) => any) | undefined;
+    onClear?: (() => 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>;

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

@@ -4,11 +4,17 @@ export type KSelectOption = {
     value: string;
 };
 export type KSelectProps = {
+    /** Shows a × that clears the selection while there is one. */
+    clearable?: boolean;
+    /** The × button's accessible name. Default `'Clear'`. */
+    clearLabel?: string;
     disabled?: boolean;
     /** Sprite href for the caret. */
     icon?: string;
     /** Renders the control inline rather than filling its container. */
     inline?: boolean;
+    /** Shows a spinner in place of the caret; the menu does not open while loading. */
+    loading?: boolean;
     menuClass?: ClassValue;
     /**
      * A bare string is used as both value and label.
@@ -23,6 +29,8 @@ export type KSelectProps = {
 };
 export type KSelectEmits = {
     change: [value: string];
+    /** The × cleared the selection; the model is now `undefined`. */
+    clear: [];
 };
 export type KSelectSlots = {
     /** Replaces the generated items. Give each one `data-kt-select-item`. */

package/dist/types/components/Skeleton/KSkeleton.vue.d.ts

@@ -0,0 +1,4 @@
+import type { KSkeletonProps } from './types';
+declare const __VLS_export: import("vue").DefineComponent<KSkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KSkeletonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,19 @@
+export type KSkeletonShape = 'rect' | 'text' | 'circle' | 'rounded';
+export type KSkeletonAnimation = 'shimmer' | 'pulse' | 'none';
+/** A CSS length, or a number of pixels. */
+export type KSkeletonSize = string | number;
+export type KSkeletonProps = {
+    /** Defaults to `rect`. */
+    shape?: KSkeletonShape;
+    /**
+     * Defaults to the full width, or the base avatar size for a `circle`. With
+     * `lines`, the width of the whole group.
+     */
+    width?: KSkeletonSize;
+    /** For a `circle`, the diameter when `width` is not given. */
+    height?: KSkeletonSize;
+    /** Number of `text` lines; the last is shortened. Defaults to 1. */
+    lines?: number;
+    /** Defaults to `shimmer`. Always off under reduced motion. */
+    animation?: KSkeletonAnimation;
+};

package/dist/types/components/Spinner/KSpinner.vue.d.ts

@@ -0,0 +1,6 @@
+import { KSpinnerProps } from './types';
+declare const __VLS_export: import("vue").DefineComponent<KSpinnerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KSpinnerProps> & Readonly<{}>, {
+    label: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,13 @@
+import { Intent, Size } from '../../types';
+export type KSpinnerSize = Extract<Size, 'sm' | 'md' | 'lg'>;
+export type KSpinnerProps = {
+    /**
+     * Hide the spinner from assistive technology. Use when adjacent visible text
+     * already announces the loading state.
+     */
+    decorative?: boolean;
+    /** Announced by screen readers to describe what is loading. */
+    label?: string;
+    size?: KSpinnerSize;
+    variant?: Intent;
+};

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

@@ -1,6 +1,13 @@
 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_base: import("vue").DefineComponent<KTableProps, {
+    /** Hands every column back to automatic layout. */
+    reset: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    resize: (widths: number[]) => any;
+}, string, import("vue").PublicProps, Readonly<KTableProps> & Readonly<{
+    onResize?: ((widths: number[]) => 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;

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

@@ -0,0 +1,4 @@
+import type { KTableResizerProps } from './types';
+declare const __VLS_export: import("vue").DefineComponent<KTableResizerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<KTableResizerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -6,11 +6,36 @@ export type KTableSize = 'md' | 'lg' | 'xl';
  * colspans — stays yours.
  */
 export type KTableProps = {
-    borderless?: boolean;
     hoverable?: boolean;
+    /**
+     * How many leading columns stay put while the table scrolls sideways, up to
+     * 4. Wrap the table in an `overflow-x: auto` container.
+     */
+    pinStart?: number;
+    /** How many trailing columns stay put, up to 4 — e.g. an actions column. */
+    pinEnd?: number;
     size?: KTableSize;
-    striped?: boolean;
+    /**
+     * Pins the header to the top of the nearest scrolling ancestor — a
+     * height-capped `overflow: auto` wrapper, or the page. Offset it with the
+     * `--kt-table-sticky-top` CSS variable, e.g. below a fixed navbar.
+     */
+    stickyHeader?: boolean;
+};
+export type KTableEmits = {
+    /**
+     * A column was resized — dragged, stepped with the arrow keys, or reset by
+     * a double-click. Carries every column's width in px, header order.
+     */
+    (event: 'resize', widths: number[]): void;
+};
+export type KTableResizerProps = {
+    /** Names the handle for assistive tech, e.g. "Resize Title". */
+    label?: string;
 };
 export type KTableSlots = {
+    /** The table's rows — `<thead>`, `<tbody>` and so on. */
     default?(): any;
+    /** Rendered inside a `<tfoot>` — pass `<tr>`s, e.g. a totals row. */
+    footer?(): any;
 };

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

@@ -1,11 +1,29 @@
-import type { ComputedRef, InjectionKey } from 'vue';
+import type { ClassValue, ComputedRef, InjectionKey } from 'vue';
 export type KTabsVariant = 'pills' | 'underline';
 export type KTabsProps = {
     /** Names the tablist. */
     ariaLabel?: string;
+    /** Classes for the panels' wrapper. */
+    contentClass?: ClassValue;
+    /**
+     * Disables every tab. The active panel stays visible, and `v-model` can
+     * still switch it.
+     */
+    disabled?: boolean;
+    /** Classes for the tablist, where the variant class also goes. */
+    listClass?: ClassValue;
+    /**
+     * Renders the tablist alone, without the panels' wrapper — for tabs that
+     * drive content elsewhere through `v-model`. The default slot is ignored.
+     */
+    noContent?: boolean;
     variant?: KTabsVariant;
 };
 export type KTabProps = {
+    /**
+     * Takes the tab out of roving focus and out of `v-model`'s reach — setting
+     * the model to its name is a no-op.
+     */
     disabled?: boolean;
     /** Matches this tab to its panel, and is what `v-model` holds. */
     name: string;
@@ -25,11 +43,15 @@ export type KTabsSlots = {
 };
 export type KTabsContext = {
     active: ComputedRef<string | undefined>;
+    disabled: ComputedRef<boolean>;
+    /** False under `noContent`, where there is no panel for a tab to control. */
+    hasPanels: ComputedRef<boolean>;
     /**
      * 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.
+     * so the id is restricted to characters that are safe unquoted.
      */
     panelId: (name: string) => string;
+    /** The tab's id, which its panel is labelled by. */
+    tabId: (name: string) => string;
 };
 export declare const tabsKey: InjectionKey<KTabsContext>;

package/dist/types/components/TagsInput/KTagsInput.vue.d.ts

@@ -0,0 +1,32 @@
+import type { KTagsInputProps, KTagsInputSlots } from './types';
+type __VLS_Props = KTagsInputProps;
+type __VLS_Slots = KTagsInputSlots;
+type __VLS_ModelProps = {
+    modelValue?: string[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    add: (value: string) => boolean;
+    clear: () => never[];
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    invalid: (value: string, reason: string) => any;
+    remove: (value: string, index: number) => any;
+    "update:modelValue": (value: string[]) => any;
+    add: (value: string) => any;
+    loadError: (error: unknown, query: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onInvalid?: ((value: string, reason: string) => any) | undefined;
+    onRemove?: ((value: string, index: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onAdd?: ((value: string) => any) | undefined;
+    onLoadError?: ((error: unknown, query: 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/TagsInput/types.d.ts

@@ -0,0 +1,68 @@
+export type KTagsInputValidator = (tag: string, tags: string[]) => true | string;
+export type KTagsInputOption = {
+    label: string;
+    value: string;
+    data?: unknown;
+};
+export type KTagsInputLoader = (query: string, context: {
+    signal: AbortSignal;
+}) => Promise<(KTagsInputOption | string)[]>;
+export type KTagsInputProps = {
+    /** Dedupe treats "Design" and "design" as different tags. */
+    caseSensitive?: boolean;
+    /** Characters that commit a tag. Enter always commits. Default `',;'`. */
+    delimiters?: string;
+    disabled?: boolean;
+    ghost?: boolean;
+    max?: number;
+    /** Renders a hidden input holding the tags joined with commas. */
+    name?: string;
+    /** Shows a spinner and marks the field busy; combined with a pending `load`. */
+    loading?: boolean;
+    /** Loads suggestions for the typed text (debounced; stale requests aborted). */
+    load?: KTagsInputLoader;
+    /** Debounce before `load` runs, in ms. Default `250`. */
+    loadDelay?: number;
+    /** Shows the whole suggestion list on focus, before anything is typed. */
+    openOnFocus?: boolean;
+    /** Suggestions shown while typing. A bare string is both label and value. */
+    options?: (KTagsInputOption | string)[];
+    placeholder?: string;
+    /** Shows the tags but hides the text field and the remove buttons. */
+    readonly?: boolean;
+    /** Only listed options can become tags; others are rejected as `'not-in-list'`. */
+    restrict?: boolean;
+    rounded?: boolean;
+    sunken?: boolean;
+    transparent?: boolean;
+    /** Return `true` to accept, or a reason string to reject. */
+    validate?: KTagsInputValidator;
+};
+export type KTagsInputEmits = {
+    add: [value: string];
+    remove: [value: string, index: number];
+    /** `reason` is `'duplicate'`, `'max'`, `'not-in-list'`, or the string `validate` returned. */
+    invalid: [value: string, reason: string];
+    loadError: [error: unknown, query: string];
+};
+export type KTagsInputSlots = {
+    /** Replaces the tag's label. The remove button is still rendered after it. */
+    tag?(props: {
+        value: string;
+        label: string;
+        index: number;
+        remove: () => void;
+    }): any;
+    /**
+     * Replaces a suggestion row's content (default: the label). Focus stays in
+     * the text field and rows are picked with Enter or a click, so put nothing
+     * focusable or interactive inside.
+     */
+    option?(props: {
+        option: KTagsInputOption;
+        active: boolean;
+        index: number;
+    }): any;
+    prefix?(): any;
+    suffix?(): any;
+};

package/dist/types/components/TagsInput/useTagsInput.d.ts

@@ -0,0 +1,27 @@
+import type { ShallowRef } from 'vue';
+import Knitify from '@knitify/core';
+type TagsInputModuleConfig = NonNullable<ConstructorParameters<typeof Knitify.modules.TagsInput>[1]>;
+type TagsInputControls = {
+    add(value: string): boolean;
+    focus(): void;
+    getValues(): string[];
+    remove(value: string): boolean;
+    setLoading(loading: boolean): void;
+    setOptions(options: (string | {
+        label: string;
+        value: string;
+    })[]): void;
+    setValues(values: string[]): void;
+};
+type Options = {
+    root: Readonly<ShallowRef<HTMLElement | null>>;
+    /** Read inside a watcher, so every prop it touches triggers a rebuild. */
+    config: () => TagsInputModuleConfig;
+    /** Pushes the current model into a freshly built module. */
+    apply: (instance: TagsInputControls) => void;
+    listeners: Record<string, (event: CustomEvent) => void>;
+};
+export declare function useTagsInput({ root, config, apply, listeners }: Options): {
+    getInstance: () => TagsInputControls | undefined;
+};
+export {};

package/dist/types/components/Time/KTime.vue.d.ts

@@ -0,0 +1,18 @@
+import type { KTimeProps } from './types';
+type __VLS_Props = KTimeProps;
+type __VLS_ModelProps = {
+    modelValue?: string | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
+    clear: () => null;
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (value: string) => any;
+    "update:modelValue": (value: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,23 @@
+export type KTimeHourCycle = 12 | 24;
+export type KTimeProps = {
+    /** `12` adds AM/PM buttons; `24` shows 00–23. The value is always 24-hour. Default `12`. */
+    hourCycle?: KTimeHourCycle;
+    /** Latest selectable time, `HH:mm` or `HH:mm:ss`, inclusive. */
+    maxTime?: string;
+    /** Earliest selectable time, `HH:mm` or `HH:mm:ss`, inclusive. */
+    minTime?: string;
+    /** Minutes per + / − press (and ↑/↓ in the field), 1–30. Default `1`. */
+    minuteStep?: number;
+    /** The Now button's label. Default `'Now'`. */
+    nowLabel?: string;
+    /** Seconds per + / − press, 1–30. Default `1`. */
+    secondStep?: number;
+    /** Adds seconds; the value becomes `HH:mm:ss`. */
+    seconds?: boolean;
+    /** Shows a Now button that picks the current time. */
+    showNow?: boolean;
+};
+export type KTimeEmits = {
+    /** Enter was pressed in a part, or Now was picked. */
+    select: [value: string];
+};

package/dist/types/components/TimeInput/KTimeInput.vue.d.ts

@@ -0,0 +1,26 @@
+import type { KTimeInputInvalidReason, KTimeInputProps } from './types';
+type __VLS_Props = KTimeInputProps;
+type __VLS_ModelProps = {
+    modelValue?: string | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
+    clear: () => null;
+    close: () => void | undefined;
+    focus: () => void | undefined;
+    open: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    open: () => any;
+    close: () => any;
+    invalid: (reason: KTimeInputInvalidReason, text: string) => any;
+    clear: () => any;
+    "update:modelValue": (value: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onOpen?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onInvalid?: ((reason: KTimeInputInvalidReason, text: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,27 @@
+import type { KTimeProps } from '../Time/types';
+export type KTimeInputInvalidReason = 'incomplete' | 'out-of-range';
+export type KTimeInputProps = KTimeProps & {
+    /** Shows a × that clears the value while there is one. */
+    clearable?: boolean;
+    /** The × button's accessible name. Default `'Clear'`. */
+    clearLabel?: string;
+    disabled?: boolean;
+    ghost?: boolean;
+    /** Shows a spinner as the last addon and disables the clock button; the field stays editable. */
+    loading?: boolean;
+    /** Posts the value (`HH:mm` or `HH:mm:ss`, 24-hour) through a hidden input. */
+    name?: string;
+    /** Defaults to the layout, e.g. `hh:mm AA`. */
+    placeholder?: string;
+    readonly?: boolean;
+    rounded?: boolean;
+    sunken?: boolean;
+    transparent?: boolean;
+};
+export type KTimeInputEmits = {
+    /** The × cleared the value. */
+    clear: [];
+    close: [];
+    invalid: [reason: KTimeInputInvalidReason, text: string];
+    open: [];
+};

package/dist/types/components/TimeInput/useTimeInput.d.ts

@@ -0,0 +1,22 @@
+import type { ShallowRef } from 'vue';
+import Knitify from '@knitify/core';
+type TimeInputModuleConfig = NonNullable<ConstructorParameters<typeof Knitify.modules.TimeInput>[1]>;
+type TimeInputControls = {
+    close(): void;
+    getValue(): string | null;
+    open(): void;
+    setValue(value: string | null): void;
+};
+type Options = {
+    root: Readonly<ShallowRef<HTMLElement | null>>;
+    /** Read inside a watcher, so every prop it touches triggers a rebuild. */
+    config: () => TimeInputModuleConfig;
+    /** Pushes the current model into a freshly built module. */
+    apply: (instance: TimeInputControls) => void;
+    listeners: Record<string, (event: CustomEvent) => void>;
+};
+export declare const syncClearButton: (element: unknown) => void;
+export declare function useTimeInput(options: Options): {
+    getInstance: () => TimeInputControls | undefined;
+};
+export {};

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

@@ -2,6 +2,8 @@ export type KToggleProps = {
     disabled?: boolean;
     /** Text beside the switch. The default slot overrides it. */
     label?: string;
+    /** Shows ON/OFF inside the track. Off by default. */
+    text?: boolean;
 };
 export type KToggleSlots = {
     default?(): any;

package/dist/types/components/Tooltip/triggerHandlers.d.ts

@@ -0,0 +1,33 @@
+import type { KTooltipProps } from './types';
+declare function onMouseover(event: MouseEvent): void;
+declare function onMouseout(event: MouseEvent): void;
+declare function onFocusin(event: FocusEvent): void;
+declare function onFocusout(event: FocusEvent): void;
+/** The trigger listeners, keyed by DOM event name. */
+export declare const triggerListeners: {
+    readonly focusin: typeof onFocusin;
+    readonly focusout: typeof onFocusout;
+    readonly mouseout: typeof onMouseout;
+    readonly mouseover: typeof onMouseover;
+};
+/** The same listeners as vnode props, for `cloneVNode`. */
+export declare const triggerListenerProps: {
+    onFocusin: typeof onFocusin;
+    onFocusout: typeof onFocusout;
+    onMouseout: typeof onMouseout;
+    onMouseover: typeof onMouseover;
+};
+/** Core's attributes for a label, placement and delay, as a plain record. */
+export declare function triggerAttributes(options: KTooltipProps): Record<string, string>;
+export declare const triggerAttributeNames: readonly ["data-kt-tooltip", "data-kt-tooltip-placement", "data-kt-tooltip-delay"];
+export declare function retainEscape(): void;
+export declare function releaseEscape(): void;
+/**
+ * A trigger unmounted while its tooltip is up would otherwise strand the
+ * bubble, which core has moved to `<body>`. With the trigger in hand, only its
+ * own tooltip closes — a row leaving a list must not close the tooltip of the
+ * row still under the pointer. Without one (KTooltip, which does not hold its
+ * child's element), every tooltip closes, as core's delegated version does.
+ */
+export declare function hideOnUnmount(trigger?: Element): void;
+export {};

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

@@ -16,3 +16,8 @@ export type KTooltipSlots = {
      */
     default?(): any;
 };
+/**
+ * The value of `v-tooltip`: a label, the full options, or a falsy value to
+ * turn the tooltip off.
+ */
+export type KTooltipDirectiveValue = string | KTooltipProps | null | undefined | false;

package/dist/types/components/Tooltip/vTooltip.d.ts

@@ -0,0 +1,10 @@
+import type { ObjectDirective } from 'vue';
+import type { KPlacement } from '../Popover/types';
+import type { KTooltipDirectiveValue } from './types';
+export declare const vTooltip: ObjectDirective<Element, KTooltipDirectiveValue, string, KPlacement>;
+export default vTooltip;
+declare module 'vue' {
+    interface GlobalDirectives {
+        vTooltip: typeof vTooltip;
+    }
+}

package/dist/types/components/Workspace/KWorkspace.vue.d.ts

@@ -1,24 +1,36 @@
-import type { KWorkspaceProps, KWorkspaceSlots } from './types';
+import type { KWorkspaceDrawer, KWorkspaceProps, KWorkspaceSlots } from './types';
 type __VLS_Props = KWorkspaceProps;
 type __VLS_Slots = KWorkspaceSlots;
 declare function toggle(): void;
 declare function expand(): void;
 declare function collapseSidebar(): void;
+declare function openDrawer(target?: KWorkspaceDrawer): void;
+declare function closeDrawer(target?: KWorkspaceDrawer): void;
+declare function toggleDrawer(target?: KWorkspaceDrawer): void;
 type __VLS_ModelProps = {
     'expanded'?: boolean;
+    'open'?: boolean;
+    'bodyOpen'?: boolean;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     toggle: typeof toggle;
     expand: typeof expand;
     collapse: typeof collapseSidebar;
+    openDrawer: typeof openDrawer;
+    closeDrawer: typeof closeDrawer;
+    toggleDrawer: typeof toggleDrawer;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:expanded": (value: boolean) => any;
+    "update:open": (value: boolean) => any;
+    "update:bodyOpen": (value: boolean) => any;
 } & {
     toggle: (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onToggle?: ((value: boolean) => any) | undefined;
     "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:bodyOpen"?: ((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;

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

@@ -1,18 +1,28 @@
 import { ClassValue } from 'vue';
 export type KWorkspaceSide = 'left' | 'right';
+export type KWorkspaceBreakpoint = 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type KWorkspaceDrawer = 'sidebar' | 'bodySidebar';
 export type KWorkspaceProps = {
     bodyClass?: ClassValue;
     bodyContentClass?: ClassValue;
+    bodyDrawerAt?: KWorkspaceBreakpoint;
+    bodyDrawerWidth?: string;
     bodySidebarClass?: ClassValue;
     bodySidebarSide?: KWorkspaceSide;
+    bodySidebarWidth?: string;
     collapsible?: boolean;
+    drawerAt?: KWorkspaceBreakpoint;
+    drawerWidth?: string;
     footerClass?: ClassValue;
     height?: string;
     mainClass?: ClassValue;
+    rounded?: boolean;
     side?: KWorkspaceSide;
     sidebarBodyClass?: ClassValue;
     sidebarClass?: ClassValue;
+    sidebarHeaderClass?: ClassValue;
     sidebarInnerClass?: ClassValue;
+    sidebarWidth?: string;
     topbarClass?: ClassValue;
 };
 export type KWorkspaceEmits = {