@knitify/vue 0.0.9 → 2.0.0

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/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

@@ -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;
+};

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

@@ -0,0 +1,45 @@
+import { type PropType, type VNode } from 'vue';
+import type { KPlacement } from '../Popover/types';
+/**
+ * Renderless by design. Core's tooltip has no content element in the markup —
+ * the trigger carries `data-kt-tooltip="label"` and core builds the bubble on
+ * first show — so this adds attributes to the trigger rather than wrapping it.
+ *
+ * That mirrors core's own docs helper, which uses React's `cloneElement`. A
+ * wrapper element would be the easy alternative, but it would sit in the layout
+ * and change how the trigger flows.
+ *
+ * A plain `<script>` rather than `<script setup>`: the component returns a
+ * render function so it can clone the slot's vnode, which a template cannot do.
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    delay: {
+        type: NumberConstructor;
+        required: false;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    placement: {
+        type: PropType<KPlacement>;
+        required: false;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    delay: {
+        type: NumberConstructor;
+        required: false;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    placement: {
+        type: PropType<KPlacement>;
+        required: false;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,18 @@
+import type { KPlacement } from '../Popover/types';
+export type KTooltipProps = {
+    /** Milliseconds to wait before opening on hover. */
+    delay?: number;
+    /**
+     * The label. Core writes it with `textContent`, so it is plain text by
+     * design — markup here would be shown literally, not rendered.
+     */
+    label: string;
+    placement?: KPlacement;
+};
+export type KTooltipSlots = {
+    /**
+     * The trigger. A single element is cloned and given core's attributes, so no
+     * extra DOM node is introduced. Anything else is wrapped in a `<span>`.
+     */
+    default?(): any;
+};

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

@@ -0,0 +1,30 @@
+import type { KWorkspaceProps, KWorkspaceSlots } from './types';
+type __VLS_Props = KWorkspaceProps;
+type __VLS_Slots = KWorkspaceSlots;
+declare function toggle(): void;
+declare function expand(): void;
+declare function collapseSidebar(): void;
+type __VLS_ModelProps = {
+    'expanded'?: 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;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:expanded": (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;
+}>, {}, {}, {}, {}, 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/Workspace/types.d.ts

@@ -0,0 +1,29 @@
+import { ClassValue } from 'vue';
+export type KWorkspaceSide = 'left' | 'right';
+export type KWorkspaceProps = {
+    bodyClass?: ClassValue;
+    bodyContentClass?: ClassValue;
+    bodySidebarClass?: ClassValue;
+    bodySidebarSide?: KWorkspaceSide;
+    collapsible?: boolean;
+    footerClass?: ClassValue;
+    height?: string;
+    mainClass?: ClassValue;
+    side?: KWorkspaceSide;
+    sidebarBodyClass?: ClassValue;
+    sidebarClass?: ClassValue;
+    sidebarInnerClass?: ClassValue;
+    topbarClass?: ClassValue;
+};
+export type KWorkspaceEmits = {
+    (event: 'toggle', value: boolean): void;
+};
+export type KWorkspaceSlots = {
+    bodySidebar?(): any;
+    default?(): any;
+    footer?(): any;
+    sidebar?(): any;
+    sidebarFooter?(): any;
+    sidebarHeader?(): any;
+    topbar?(): any;
+};

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

@@ -1,6 +1,62 @@
+export { accordionGroupKey } from './Accordion/keys';
+export { chatBusyKey } from './Chat/keys';
+export { chatDockKey } from './ChatDock/keys';
+export { chatDockStoreKey, injectChatDock, provideChatDock, } from './ChatDock/store-keys';
+export { useChatDock } from './ChatDock/useChatDock';
+export { default as KAccordion } from './Accordion/KAccordion.vue';
+export { default as KAccordionItem } from './Accordion/KAccordionItem.vue';
+export { default as KAlert } from './Alert/KAlert.vue';
+export { default as KAvatar } from './Avatar/KAvatar.vue';
+export { default as KAvatarGroup } from './Avatar/KAvatarGroup.vue';
+export { default as KBadge } from './Badge/KBadge.vue';
+export { default as KBreadcrumb } from './Breadcrumb/KBreadcrumb.vue';
+export { default as KBreadcrumbItem } from './Breadcrumb/KBreadcrumbItem.vue';
 export { default as KButton } from './Button/KButton.vue';
+export { default as KCalendar } from './Calendar/KCalendar.vue';
+export { default as KCard } from './Card/KCard.vue';
+export { default as KChat } from './Chat/KChat.vue';
+export { default as KChatDock } from './ChatDock/KChatDock.vue';
+export { default as KChatDockItem } from './ChatDock/KChatDockItem.vue';
+export { default as KChatDockPanel } from './ChatDock/KChatDockPanel.vue';
+export { default as KChatDivider } from './Chat/KChatDivider.vue';
+export { default as KMessenger } from './ChatDock/KMessenger.vue';
+export { default as KChatMessage } from './Chat/KChatMessage.vue';
+export { default as KChatMessageActions } from './Chat/KChatMessageActions.vue';
+export { default as KChatMessages } from './Chat/KChatMessages.vue';
+export { default as KChatNotice } from './Chat/KChatNotice.vue';
+export { default as KChatPrompt } from './Chat/KChatPrompt.vue';
+export { default as KChatShimmer } from './Chat/KChatShimmer.vue';
+export { default as KChatWindow } from './ChatDock/KChatWindow.vue';
+export { default as KCheckbox } from './Checkbox/KCheckbox.vue';
+export { default as KCollapse } from './Collapse/KCollapse.vue';
 export { default as KContainer } from './Container/KContainer.vue';
+export { default as KDrawer } from './Drawer/KDrawer.vue';
+export { default as KDropdown } from './Dropdown/KDropdown.vue';
+export { default as KDropdownItem } from './Dropdown/KDropdownItem.vue';
+export { default as KDropdownMenu } from './Dropdown/KDropdownMenu.vue';
+export { default as KFileTree } from './FileTree/KFileTree.vue';
+export { default as KGrid } from './Grid/KGrid.vue';
+export { default as KGridColumn } from './Grid/KGridColumn.vue';
+export { default as KGridRow } from './Grid/KGridRow.vue';
 export { default as KIcon } from './Icon/KIcon.vue';
 export { default as KInput } from './Input/KInput.vue';
+export { default as KMenuList } from './MenuList/KMenuList.vue';
+export { default as KMenuListItem } from './MenuList/KMenuListItem.vue';
+export { default as KModal } from './Modal/KModal.vue';
 export { default as KNavbar } from './Navbar/KNavbar.vue';
 export { default as KNavbarMenu } from './Navbar/KNavbarMenu.vue';
+export { default as KNotificationList } from './NotificationList/KNotificationList.vue';
+export { default as KNotificationListItem } from './NotificationList/KNotificationListItem.vue';
+export { default as KPopover } from './Popover/KPopover.vue';
+export { default as KProgress } from './Progress/KProgress.vue';
+export { default as KRadio } from './Radio/KRadio.vue';
+export { default as KSelect } from './Select/KSelect.vue';
+export { default as KSpinner } from './Spinner/KSpinner.vue';
+export { default as KTab } from './Tabs/KTab.vue';
+export { default as KTable } from './Table/KTable.vue';
+export { default as KTabPanel } from './Tabs/KTabPanel.vue';
+export { default as KTabs } from './Tabs/KTabs.vue';
+export { default as KToggle } from './Toggle/KToggle.vue';
+export { default as KTooltip } from './Tooltip/KTooltip.vue';
+export { default as KWorkspace } from './Workspace/KWorkspace.vue';
+export { useToast } from './Toast/useToast';

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

@@ -1,5 +1,36 @@
+export * from './Accordion/types';
+export * from './Alert/types';
+export * from './Avatar/types';
+export * from './Badge/types';
+export * from './Breadcrumb/types';
 export * from './Button/types';
+export * from './Calendar/types';
+export * from './Card/types';
+export * from './Chat/types';
+export type { ChatDockCallResult, ChatDockContext, ChatDockInstance, } from './ChatDock/keys';
+export * from './ChatDock/types';
+export * from './ChatDock/messenger-types';
+export * from './Checkbox/types';
+export * from './Collapse/types';
 export * from './Container/types';
+export * from './Drawer/types';
+export * from './Dropdown/types';
+export * from './FileTree/types';
+export * from './Grid/types';
 export * from './Icon/types';
 export * from './Input/types';
+export * from './MenuList/types';
+export * from './Modal/types';
 export * from './Navbar/types';
+export * from './NotificationList/types';
+export * from './Popover/types';
+export * from './Progress/types';
+export * from './Radio/types';
+export * from './Select/types';
+export * from './Spinner/types';
+export * from './Table/types';
+export * from './Tabs/types';
+export * from './Toast/types';
+export * from './Toggle/types';
+export * from './Tooltip/types';
+export * from './Workspace/types';

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 import { App } from 'vue';
+export * from './types';
 export * from './components/types';
 export * from './components';
 declare const _default: {

package/dist/types/types.d.ts

@@ -1,2 +1,3 @@
 export type Size = '5xs' | '4xs' | '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl';
 export type Variant = 'brand' | 'success' | 'info' | 'attention' | 'danger';
+export type Intent = 'caution' | 'warning' | 'critical' | 'info' | 'discovery' | 'affirm';

package/dist/types/utils/useDocumentEvent.d.ts

@@ -0,0 +1,19 @@
+import { type Ref } from 'vue';
+export type DocumentEventOptions = {
+    capture?: boolean;
+};
+/**
+ * A `document` listener that exists only while `active` is true.
+ *
+ * Outside-click and Escape cannot be bound to the component's own element —
+ * they are about events that happen elsewhere. Core solves this with a
+ * permanent delegated listener that runs on every click on the page and then
+ * queries the DOM for anything open. Scoping the listener to the open state
+ * instead means a closed component costs nothing, and the handler never has to
+ * ask whether it should be running.
+ *
+ * Registered on the next tick after `active` turns true, so the very click or
+ * keypress that opened the component cannot immediately close it again by
+ * reaching this listener as it bubbles.
+ */
+export declare function useDocumentEvent(active: Ref<boolean>, type: string, handler: (event: any) => void, options?: DocumentEventOptions): void;

package/dist/types/utils/useExclusive.d.ts

@@ -0,0 +1,13 @@
+import { type Ref } from 'vue';
+/**
+ * Opening this overlay closes every other mounted member of `group`.
+ *
+ * Core got this from its delegated toggles, which swept the page — Popover
+ * hiding every other `[data-kt-popover].is-active`, Dropdown and Select calling
+ * `destroyAll`. Once each component binds its own toggle there is no sweep, so
+ * the group replaces it.
+ *
+ * Dropdowns and selects share one group, as they did in core: `Select` extends
+ * `Dropdown`, and opening either closed the other.
+ */
+export declare function useExclusive(group: string, open: Ref<boolean>, close: () => void): void;

package/dist/types/utils/useTopmost.d.ts

@@ -0,0 +1,17 @@
+import { type Ref } from 'vue';
+/**
+ * Tracks whether this overlay is the innermost open one of its kind.
+ *
+ * Core answered the same question with a single delegated Escape handler that
+ * closed the first `.is-active` overlay it found. Once each component binds its
+ * own Escape, they would all close together, so the stack keeps that to one.
+ *
+ * Modals and drawers keep separate stacks, matching core's independent
+ * handlers: Escape in a drawer opened over a modal closes the drawer only.
+ *
+ * `priority` breaks the ordering where recency is the wrong answer. Core's
+ * drawer handler preferred a drawer with a backdrop over a `noBackdrop` one
+ * regardless of which opened last, since the latter is a persistent panel
+ * rather than something Escape should dismiss.
+ */
+export declare function useTopmost(name: string, active: Ref<boolean>, priority?: () => number): () => boolean;