@datametria/vue-components 2.1.0 → 2.1.1

package/dist/src/components/DatametriaNavbar.vue.d.ts

@@ -0,0 +1,34 @@
+interface Props {
+    brand?: string;
+    variant?: 'light' | 'dark' | 'transparent' | 'primary';
+    sticky?: boolean;
+    transparent?: boolean;
+    bordered?: boolean;
+    ariaLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        brand?(_: {}): any;
+        menu?(_: {}): any;
+        actions?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    variant: "light" | "dark" | "transparent" | "primary";
+    ariaLabel: string;
+    transparent: boolean;
+    brand: string;
+    sticky: boolean;
+    bordered: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/src/components/DatametriaPasswordInput.vue.d.ts

@@ -0,0 +1,29 @@
+interface Props {
+    modelValue?: string;
+    label?: string;
+    placeholder?: string;
+    errorMessage?: string;
+    helpText?: string;
+    disabled?: boolean;
+    required?: boolean;
+    minLength?: number;
+    showStrength?: boolean;
+    showRequirements?: boolean;
+    autocomplete?: 'current-password' | 'new-password';
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    "strength-change": (strength: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onStrength-change"?: ((strength: number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string;
+    required: boolean;
+    minLength: number;
+    showStrength: boolean;
+    showRequirements: boolean;
+    autocomplete: "current-password" | "new-password";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaProgress.vue.d.ts

@@ -0,0 +1,12 @@
+interface Props {
+    value: number;
+    label?: string;
+    variant?: 'primary' | 'success' | 'warning' | 'error';
+    showValue?: boolean;
+    ariaLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    variant: "primary" | "success" | "warning" | "error";
+    showValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaRadio.vue.d.ts

@@ -0,0 +1,17 @@
+interface Props {
+    modelValue?: string | number | boolean;
+    value: string | number | boolean;
+    label?: string;
+    name?: string;
+    disabled?: boolean;
+    error?: string;
+    ariaLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number | boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number | boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaSelect.vue.d.ts

@@ -0,0 +1,23 @@
+interface Option {
+    value: string | number;
+    label: string;
+}
+interface Props {
+    modelValue?: string | number;
+    options: Option[];
+    label?: string;
+    placeholder?: string;
+    errorMessage?: string;
+    disabled?: boolean;
+    required?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string | number;
+    required: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaSidebar.vue.d.ts

@@ -0,0 +1,45 @@
+interface Props {
+    position?: 'left' | 'right';
+    variant?: 'light' | 'dark' | 'primary';
+    width?: string;
+    collapsible?: boolean;
+    defaultOpen?: boolean;
+    ariaLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    isOpen: import('vue').Ref<boolean, boolean>;
+    toggle: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    open: () => any;
+    close: () => any;
+    toggle: (isOpen: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onOpen?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onToggle?: ((isOpen: boolean) => any) | undefined;
+}>, {
+    variant: "light" | "dark" | "primary";
+    width: string;
+    ariaLabel: string;
+    position: "left" | "right";
+    collapsible: boolean;
+    defaultOpen: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/src/components/DatametriaSkeleton.vue.d.ts

@@ -0,0 +1,18 @@
+type SkeletonVariant = 'text' | 'avatar' | 'card' | 'button' | 'custom';
+interface Props {
+    variant?: SkeletonVariant;
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+    animated?: boolean;
+    ariaLabel?: string;
+    lastLineWidth?: number;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    variant: SkeletonVariant;
+    ariaLabel: string;
+    lines: number;
+    animated: boolean;
+    lastLineWidth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaSlider.vue.d.ts

@@ -0,0 +1,41 @@
+interface Props {
+    modelValue: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    label?: string;
+    disabled?: boolean;
+    required?: boolean;
+    showValue?: boolean;
+    showMinMax?: boolean;
+    errorMessage?: string;
+    helperText?: string;
+    ariaLabel?: string;
+    formatter?: (value: number) => string;
+}
+declare const _default: import('vue').DefineComponent<Props, {
+    focus: () => void;
+    blur: () => void;
+    inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    input: (value: number) => any;
+    "update:modelValue": (value: number) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: number) => any;
+    focus: (event: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onInput?: ((value: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: number) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+}>, {
+    min: number;
+    max: number;
+    step: number;
+    showValue: boolean;
+    showMinMax: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaSortableTable.vue.d.ts

@@ -0,0 +1,32 @@
+import { SortableTableProps } from '../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`cell-${string}`, (_: {
+        row: Record<string, any>;
+        value: any;
+    }) => any>> & {
+        empty?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SortableTableProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "selection-change": (selectedIds: (string | number)[]) => any;
+}, string, import('vue').PublicProps, Readonly<SortableTableProps> & Readonly<{
+    "onSelection-change"?: ((selectedIds: (string | number)[]) => any) | undefined;
+}>, {
+    selectable: boolean;
+    searchable: boolean;
+    filterable: boolean;
+    paginated: boolean;
+    pageSize: number;
+    pageSizeOptions: number[];
+}, {}, {}, {}, 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/src/components/DatametriaSpinner.vue.d.ts

@@ -0,0 +1,12 @@
+interface Props {
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'primary' | 'secondary' | 'white';
+    label?: string;
+    ariaLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    variant: "primary" | "secondary" | "white";
+    size: "sm" | "md" | "lg";
+    ariaLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaSwitch.vue.d.ts

@@ -0,0 +1,16 @@
+interface Props {
+    modelValue?: boolean;
+    label?: string;
+    disabled?: boolean;
+    error?: string;
+    ariaLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaTable.vue.d.ts

@@ -0,0 +1,29 @@
+interface Column {
+    key: string;
+    label: string;
+    width?: string;
+}
+interface Props {
+    columns: Column[];
+    data: Record<string, any>[];
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`cell-${string}`, (_: {
+        row: Record<string, any>;
+        value: any;
+    }) => any>> & {
+        empty?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, 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/src/components/DatametriaTabs.vue.d.ts

@@ -0,0 +1,41 @@
+interface Tab {
+    label: string;
+    icon?: string;
+    badge?: string | number;
+    disabled?: boolean;
+}
+interface Props {
+    tabs: (string | Tab)[];
+    modelValue?: number;
+    variant?: 'default' | 'pills' | 'underline';
+    orientation?: 'horizontal' | 'vertical';
+    showIndicator?: boolean;
+    ariaLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`panel-${number}`, (_: {}) => any>>;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (index: number) => any;
+    change: (index: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+    onChange?: ((index: number) => any) | undefined;
+}>, {
+    variant: "default" | "pills" | "underline";
+    modelValue: number;
+    ariaLabel: string;
+    orientation: "horizontal" | "vertical";
+    showIndicator: 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/src/components/DatametriaTextarea.vue.d.ts

@@ -0,0 +1,22 @@
+interface Props {
+    modelValue?: string;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    error?: string;
+    rows?: number;
+    maxLength?: number;
+    ariaLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string;
+    required: boolean;
+    rows: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaTimePicker.vue.d.ts

@@ -0,0 +1,36 @@
+interface Props {
+    modelValue?: string;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    errorMessage?: string;
+    successMessage?: string;
+    helperText?: string;
+    min?: string;
+    max?: string;
+    step?: number;
+    format24h?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {
+    focus: () => void;
+    blur: () => void;
+    inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: string) => any;
+    focus: (event: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+}>, {
+    modelValue: string;
+    step: number;
+    format24h: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/src/components/DatametriaToast.vue.d.ts

@@ -0,0 +1,20 @@
+interface Props {
+    message: string;
+    variant?: 'success' | 'error' | 'warning' | 'info' | 'primary';
+    duration?: number;
+    closable?: boolean;
+    modelValue?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    close: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+}>, {
+    variant: "success" | "error" | "warning" | "info" | "primary";
+    modelValue: boolean;
+    closable: boolean;
+    duration: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/DatametriaTooltip.vue.d.ts

@@ -0,0 +1,58 @@
+type Placement = 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+type Variant = 'dark' | 'light' | 'primary' | 'error' | 'warning' | 'success';
+type Trigger = 'hover' | 'click' | 'focus' | 'manual';
+interface Props {
+    content?: string;
+    placement?: Placement;
+    variant?: Variant;
+    trigger?: Trigger;
+    disabled?: boolean;
+    showArrow?: boolean;
+    delay?: number;
+    hideDelay?: number;
+    offset?: number;
+    maxWidth?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLDivElement;
+        tooltipRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    show: () => void;
+    hide: () => void;
+    isVisible: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    show: () => any;
+    hide: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onShow?: (() => any) | undefined;
+    onHide?: (() => any) | undefined;
+}>, {
+    variant: Variant;
+    maxWidth: string;
+    placement: Placement;
+    trigger: Trigger;
+    showArrow: boolean;
+    delay: number;
+    hideDelay: number;
+    offset: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRef: HTMLDivElement;
+    tooltipRef: HTMLDivElement;
+}, 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/src/composables/useAPI.d.ts

@@ -0,0 +1,14 @@
+export interface ApiConfig {
+    baseURL?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+export declare function useAPI(config?: ApiConfig): {
+    loading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<string | null, string | null>;
+    data: import('vue').Ref<any, any>;
+    get: (url: string, options?: RequestInit) => Promise<any>;
+    post: (url: string, body: any, options?: RequestInit) => Promise<any>;
+    put: (url: string, body: any, options?: RequestInit) => Promise<any>;
+    delete: (url: string, options?: RequestInit) => Promise<any>;
+};

package/dist/src/composables/useAccessibilityScale.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Composable para controle de escalabilidade de acessibilidade
+ * Implementa escala controlada entre 0.8x e 2.0x conforme WCAG 2.1
+ */
+export declare function useAccessibilityScale(): {
+    scale: import('vue').ComputedRef<number>;
+    scaleClass: import('vue').ComputedRef<"scale-small" | "scale-large" | "scale-normal">;
+    setScale: (newScale: number) => void;
+    increaseScale: () => void;
+    decreaseScale: () => void;
+    resetScale: () => void;
+    minScale: number;
+    maxScale: number;
+};

package/dist/src/composables/useBreakpoints.d.ts

@@ -0,0 +1,33 @@
+export declare const breakpoints: {
+    readonly xs: 475;
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+    readonly '2xl': 1536;
+};
+export type Breakpoint = keyof typeof breakpoints;
+export declare function useBreakpoints(): {
+    windowWidth: import('vue').Ref<number, number>;
+    breakpoints: {
+        readonly xs: 475;
+        readonly sm: 640;
+        readonly md: 768;
+        readonly lg: 1024;
+        readonly xl: 1280;
+        readonly '2xl': 1536;
+    };
+    isGreaterOrEqual: (breakpoint: Breakpoint) => boolean;
+    isLessOrEqual: (breakpoint: Breakpoint) => boolean;
+    isBetween: (min: Breakpoint, max: Breakpoint) => boolean;
+    getCurrentBreakpoint: () => Breakpoint;
+    isXs: () => boolean;
+    isSm: () => boolean;
+    isMd: () => boolean;
+    isLg: () => boolean;
+    isXl: () => boolean;
+    is2xl: () => boolean;
+    isMobile: () => boolean;
+    isTablet: () => boolean;
+    isDesktop: () => boolean;
+};

package/dist/src/composables/useClipboard.d.ts

@@ -0,0 +1,6 @@
+export declare function useClipboard(): {
+    copied: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<string | null, string | null>;
+    copy: (text: string) => Promise<boolean>;
+    read: () => Promise<string>;
+};

package/dist/src/composables/useDebounce.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useDebounce<T>(value: Ref<T>, delay?: number): Ref<T>;

package/dist/src/composables/useHapticFeedback.d.ts

@@ -0,0 +1,34 @@
+type HapticType = 'light' | 'medium' | 'heavy' | 'selection' | 'impact' | 'notification';
+type NotificationType = 'success' | 'warning' | 'error';
+interface HapticOptions {
+    enabled?: boolean;
+    fallbackToVisual?: boolean;
+    visualDuration?: number;
+}
+/**
+ * Composable para feedback háptico e visual
+ * Suporta dispositivos iOS/Android com fallback visual
+ */
+export declare function useHapticFeedback(options?: HapticOptions): {
+    isSupported: import('vue').Ref<boolean, boolean>;
+    isEnabled: import('vue').Ref<boolean, boolean>;
+    canVibrate: import('vue').ComputedRef<boolean>;
+    hasVisualFeedback: import('vue').ComputedRef<boolean>;
+    activeVisualFeedback: import('vue').Ref<string | null, string | null>;
+    triggerHaptic: (type?: HapticType | NotificationType) => any;
+    triggerVisualFeedback: (element: HTMLElement | null, type: HapticType | NotificationType) => void;
+    feedback: (element: HTMLElement | null, type: HapticType | NotificationType) => any;
+    checkSupport: () => boolean;
+    light: (element?: HTMLElement) => void;
+    medium: (element?: HTMLElement) => void;
+    heavy: (element?: HTMLElement) => void;
+    selection: (element?: HTMLElement) => void;
+    impact: (intensity?: "light" | "medium" | "heavy", element?: HTMLElement) => void;
+    notification: (type: NotificationType, element?: HTMLElement) => void;
+    custom: (pattern: number | number[], element?: HTMLElement) => void;
+    enable: () => void;
+    disable: () => void;
+    toggle: () => void;
+    detectHapticSupport: () => boolean;
+};
+export {};

package/dist/src/composables/useLocalStorage.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useLocalStorage<T>(key: string, defaultValue: T): Ref<T>;