@dskripchenko/ui 0.0.1

package/dist/components/Select/UidSelect.vue.d.ts

@@ -0,0 +1,37 @@
+export interface SelectOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+}
+export interface UidSelectProps {
+    options: SelectOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+type __VLS_Props = UidSelectProps;
+type __VLS_PublicProps = {
+    modelValue?: string | number | null;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number | null) => any;
+    change: (value: string | number | null) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number | null) => any) | undefined;
+    onChange?: ((value: string | number | null) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    disabled: boolean;
+    placeholder: string;
+    searchable: boolean;
+    clearable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+    triggerRef: HTMLDivElement;
+    searchRef: HTMLInputElement;
+    listRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as UidSelect } from './UidSelect.vue';
+export type { UidSelectProps, SelectOption } from './UidSelect.vue';

package/dist/components/Skeleton/UidSkeleton.vue.d.ts

@@ -0,0 +1,13 @@
+export interface UidSkeletonProps {
+    width?: string;
+    height?: string;
+    rounded?: boolean | 'full';
+    lines?: number;
+}
+declare const _default: import('vue').DefineComponent<UidSkeletonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidSkeletonProps> & Readonly<{}>, {
+    width: string;
+    height: string;
+    rounded: boolean | "full";
+    lines: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as UidSkeleton } from './UidSkeleton.vue';
+export type { UidSkeletonProps } from './UidSkeleton.vue';

package/dist/components/Slider/UidSlider.vue.d.ts

@@ -0,0 +1,27 @@
+export interface UidSliderProps {
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    label?: string;
+    showValue?: boolean;
+    formatValue?: (val: number) => string;
+}
+type __VLS_Props = UidSliderProps;
+type __VLS_PublicProps = {
+    modelValue?: number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    label: string;
+    disabled: boolean;
+    min: number;
+    max: number;
+    showValue: boolean;
+    step: number;
+    formatValue: (val: number) => string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as UidSlider } from './UidSlider.vue';
+export type { UidSliderProps } from './UidSlider.vue';

package/dist/components/Spinner/UidSpinner.vue.d.ts

@@ -0,0 +1,10 @@
+import { Size } from '../../types/index.js';
+export interface UidSpinnerProps {
+    size?: Size;
+    label?: string;
+}
+declare const _default: import('vue').DefineComponent<UidSpinnerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidSpinnerProps> & Readonly<{}>, {
+    size: Size;
+    label: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as UidSpinner } from './UidSpinner.vue';
+export type { UidSpinnerProps } from './UidSpinner.vue';

package/dist/components/Stack/UidStack.vue.d.ts

@@ -0,0 +1,36 @@
+export interface UidStackProps {
+    direction?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    gap?: string;
+    align?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+    wrap?: boolean;
+    as?: string;
+    inline?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): unknown;
+    }> & {
+        default(): unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UidStackProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidStackProps> & Readonly<{}>, {
+    inline: boolean;
+    direction: "row" | "column" | "row-reverse" | "column-reverse";
+    as: string;
+    gap: string;
+    align: "start" | "center" | "end" | "stretch" | "baseline";
+    justify: "start" | "center" | "end" | "between" | "around" | "evenly";
+    wrap: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as UidStack } from './UidStack.vue';
+export type { UidStackProps } from './UidStack.vue';

package/dist/components/Stepper/UidStepper.vue.d.ts

@@ -0,0 +1,14 @@
+export interface StepperStep {
+    label: string;
+    description?: string;
+}
+export interface UidStepperProps {
+    steps: StepperStep[];
+    current?: number;
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const _default: import('vue').DefineComponent<UidStepperProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidStepperProps> & Readonly<{}>, {
+    orientation: "horizontal" | "vertical";
+    current: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLOListElement>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as UidStepper } from './UidStepper.vue';
+export type { UidStepperProps, StepperStep } from './UidStepper.vue';

package/dist/components/Switch/UidSwitch.vue.d.ts

@@ -0,0 +1,32 @@
+import { Size } from '../../types/index.js';
+export interface UidSwitchProps {
+    label?: string;
+    hint?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    id?: string;
+    size?: Size;
+}
+type __VLS_Props = UidSwitchProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    change: (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChange?: ((value: boolean) => any) | undefined;
+}>, {
+    size: Size;
+    label: string;
+    required: boolean;
+    disabled: boolean;
+    hint: string;
+    error: string;
+    name: string;
+    id: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as UidSwitch } from './UidSwitch.vue';
+export type { UidSwitchProps } from './UidSwitch.vue';

package/dist/components/Table/UidTable.vue.d.ts

@@ -0,0 +1,49 @@
+export interface UidTableColumn {
+    key: string;
+    label: string;
+    sortable?: boolean;
+    align?: 'left' | 'center' | 'right';
+    width?: string;
+}
+export interface UidTableProps {
+    columns: UidTableColumn[];
+    data: Record<string, unknown>[];
+    sortKey?: string;
+    sortDirection?: 'asc' | 'desc';
+    loading?: boolean;
+    emptyText?: string;
+    striped?: boolean;
+    bordered?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        [key: string]: (row?: Record<string, unknown>) => unknown;
+    }> & {
+        [key: string]: (row?: Record<string, unknown>) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UidTableProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:sortKey": (key: string) => any;
+    "update:sortDirection": (dir: "desc" | "asc") => any;
+}, string, import('vue').PublicProps, Readonly<UidTableProps> & Readonly<{
+    "onUpdate:sortKey"?: ((key: string) => any) | undefined;
+    "onUpdate:sortDirection"?: ((dir: "desc" | "asc") => any) | undefined;
+}>, {
+    loading: boolean;
+    sortKey: string;
+    sortDirection: "asc" | "desc";
+    emptyText: string;
+    striped: boolean;
+    bordered: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as UidTable } from './UidTable.vue';
+export type { UidTableProps, UidTableColumn } from './UidTable.vue';

package/dist/components/Tabs/UidTab.vue.d.ts

@@ -0,0 +1,26 @@
+import { TabValue } from './context.js';
+export interface UidTabProps {
+    value: TabValue;
+    disabled?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): unknown;
+    }> & {
+        default(): unknown;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UidTabProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidTabProps> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Tabs/UidTabPanel.vue.d.ts

@@ -0,0 +1,23 @@
+import { TabValue } from './context.js';
+export interface UidTabPanelProps {
+    value: TabValue;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): unknown;
+    }> & {
+        default(): unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UidTabPanelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidTabPanelProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Tabs/UidTabs.vue.d.ts

@@ -0,0 +1,35 @@
+import { TabValue } from './context.js';
+export interface UidTabsProps {
+    orientation?: 'horizontal' | 'vertical';
+}
+type __VLS_Props = UidTabsProps;
+type __VLS_PublicProps = {
+    modelValue: TabValue;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        list(): unknown;
+        default(): unknown;
+    }> & {
+        list(): unknown;
+        default(): unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: TabValue) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: TabValue) => any) | undefined;
+}>, {
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,8 @@
+import { InjectionKey, Ref } from 'vue';
+export type TabValue = string | number;
+export interface TabsContext {
+    activeTab: Ref<TabValue>;
+    setTab: (value: TabValue) => void;
+    idPrefix: string;
+}
+export declare const TABS_KEY: InjectionKey<TabsContext>;

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

@@ -0,0 +1,7 @@
+export { default as UidTabs } from './UidTabs.vue';
+export { default as UidTab } from './UidTab.vue';
+export { default as UidTabPanel } from './UidTabPanel.vue';
+export type { UidTabsProps } from './UidTabs.vue';
+export type { UidTabProps } from './UidTab.vue';
+export type { UidTabPanelProps } from './UidTabPanel.vue';
+export type { TabValue } from './context.js';

package/dist/components/Tag/UidTag.vue.d.ts

@@ -0,0 +1,34 @@
+import { Tone } from '../../types/index.js';
+export type UidTagVariant = Tone | 'default';
+export interface UidTagProps {
+    variant?: UidTagVariant;
+    size?: 'sm' | 'md';
+    dismissible?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): unknown;
+    }> & {
+        default(): unknown;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UidTagProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    dismiss: () => any;
+}, string, import('vue').PublicProps, Readonly<UidTagProps> & Readonly<{
+    onDismiss?: (() => any) | undefined;
+}>, {
+    size: "sm" | "md";
+    variant: UidTagVariant;
+    dismissible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as UidTag } from './UidTag.vue';
+export type { UidTagProps, UidTagVariant } from './UidTag.vue';

package/dist/components/Textarea/UidTextarea.vue.d.ts

@@ -0,0 +1,53 @@
+import { Size } from '../../types/index.js';
+import { RuleInput } from '../../utils/validation/types.js';
+export interface UidTextareaProps {
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: Size;
+    label?: string;
+    hint?: string;
+    error?: string;
+    required?: boolean;
+    name?: string;
+    rules?: RuleInput;
+    id?: string;
+    rows?: number;
+    autoGrow?: boolean;
+    maxRows?: number;
+    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
+}
+type __VLS_Props = UidTextareaProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    validate: () => boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    size: Size;
+    label: string;
+    required: boolean;
+    disabled: boolean;
+    placeholder: string;
+    readonly: boolean;
+    hint: string;
+    error: string;
+    name: string;
+    rules: RuleInput;
+    id: string;
+    rows: number;
+    autoGrow: boolean;
+    maxRows: number;
+    resize: "none" | "vertical" | "horizontal" | "both";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    textareaRef: HTMLTextAreaElement;
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as UidTextarea } from './UidTextarea.vue';
+export type { UidTextareaProps } from './UidTextarea.vue';

package/dist/components/Toast/UidToast.vue.d.ts

@@ -0,0 +1,16 @@
+import { Tone } from '../../types/index.js';
+export interface UidToastProps {
+    id: number;
+    message: string;
+    variant?: Tone;
+    title?: string;
+}
+declare const _default: import('vue').DefineComponent<UidToastProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    dismiss: (id: number) => any;
+}, string, import('vue').PublicProps, Readonly<UidToastProps> & Readonly<{
+    onDismiss?: ((id: number) => any) | undefined;
+}>, {
+    variant: Tone;
+    title: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/Toast/UidToastProvider.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { default as UidToast } from './UidToast.vue';
+export type { UidToastProps } from './UidToast.vue';
+export { default as UidToastProvider } from './UidToastProvider.vue';

package/dist/components/Tooltip/UidTooltip.vue.d.ts

@@ -0,0 +1,34 @@
+import { Placement } from '../../composables/usePopover.js';
+export interface UidTooltipProps {
+    content: string;
+    placement?: Placement;
+    disabled?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): unknown;
+    }> & {
+        default(): unknown;
+    };
+    refs: {
+        referenceRef: HTMLDivElement;
+        floatingRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UidTooltipProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidTooltipProps> & Readonly<{}>, {
+    disabled: boolean;
+    placement: Placement;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    referenceRef: HTMLDivElement;
+    floatingRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as UidTooltip } from './UidTooltip.vue';
+export type { UidTooltipProps } from './UidTooltip.vue';

package/dist/components/VirtualList/UidVirtualList.vue.d.ts

@@ -0,0 +1,29 @@
+export interface UidVirtualListProps<T> {
+    items: T[];
+    itemHeight: number;
+    height: number | string;
+    overscan?: number;
+}
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & UidVirtualListProps<T> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        item(props: {
+            item: T;
+            index: number;
+        }): unknown;
+    }> & {
+        item(props: {
+            item: T;
+            index: number;
+        }): unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,2 @@
+export { default as UidVirtualList } from './UidVirtualList.vue';
+export type { UidVirtualListProps } from './UidVirtualList.vue';

package/dist/composables/useCommandPalette.d.ts

@@ -0,0 +1,6 @@
+export declare function useCommandPalette(): {
+    open: import('vue').Ref<boolean, boolean>;
+    show: () => void;
+    hide: () => void;
+    toggle: () => void;
+};

package/dist/composables/useField.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'vue';
+import { RuleInput } from '../utils/validation/types';
+export interface UseFieldOptions {
+    name?: string;
+    label?: string;
+    form?: Ref<Record<string, unknown> | undefined>;
+}
+export declare function useField(value: Ref<unknown>, rules?: RuleInput | Ref<RuleInput | undefined>, options?: UseFieldOptions): {
+    error: Ref<string, string>;
+    touched: Ref<boolean, boolean>;
+    validate: () => boolean;
+    onBlur: () => void;
+    reset: () => void;
+};

package/dist/composables/useFocusTrap.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export declare function useFocusTrap(containerRef: Ref<HTMLElement | null>): {
+    activate: (initialFocusRef?: Ref<HTMLElement | null>) => void;
+    deactivate: () => void;
+};

package/dist/composables/usePopover.d.ts

@@ -0,0 +1,17 @@
+import { Ref, MaybeRef } from 'vue';
+export type Placement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
+export interface UsePopoverOptions {
+    placement?: MaybeRef<Placement>;
+    offset?: number;
+}
+export declare function usePopover(referenceRef: Ref<HTMLElement | null>, floatingRef: Ref<HTMLElement | null>, options?: UsePopoverOptions): {
+    x: Ref<number, number>;
+    y: Ref<number, number>;
+    actualPlacement: Ref<Placement, Placement>;
+    floatingStyle: import('vue').ComputedRef<{
+        position: "fixed";
+        left: string;
+        top: string;
+    }>;
+    update: () => void;
+};

package/dist/composables/useScrollLock.d.ts

@@ -0,0 +1,4 @@
+export declare function useScrollLock(): {
+    lock: () => void;
+    unlock: () => void;
+};

package/dist/composables/useSidebar.d.ts

@@ -0,0 +1,9 @@
+import { InjectionKey, Ref } from 'vue';
+export interface SidebarContext {
+    collapsed: Ref<boolean>;
+    toggle: () => void;
+    open: () => void;
+    close: () => void;
+}
+export declare const SIDEBAR_LAYOUT_KEY: InjectionKey<SidebarContext>;
+export declare function useSidebar(): SidebarContext;

package/dist/composables/useTheme.d.ts

@@ -0,0 +1,8 @@
+export type Theme = 'light' | 'dark';
+export declare function useTheme(): {
+    theme: import('vue').Ref<Theme, Theme>;
+    setTheme: (value: Theme) => void;
+    toggle: () => void;
+    initFromSystem: () => void;
+    watchSystem: () => void;
+};