@datametria/vue-components 2.1.0 → 2.2.0

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

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

@@ -0,0 +1,49 @@
+interface RippleOptions {
+    color?: string;
+    duration?: number;
+    disabled?: boolean;
+}
+interface RippleEffect {
+    x: number;
+    y: number;
+    size: number;
+    id: string;
+}
+/**
+ * Composable para efeito ripple em elementos clicáveis
+ * Implementa Material Design ripple effect com acessibilidade
+ */
+export declare function useRipple(options?: RippleOptions): {
+    rippleRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    ripples: import('vue').Ref<{
+        x: number;
+        y: number;
+        size: number;
+        id: string;
+    }[], RippleEffect[] | {
+        x: number;
+        y: number;
+        size: number;
+        id: string;
+    }[]>;
+    applyRipple: (element: HTMLElement) => (() => void) | undefined;
+    removeRipple: (id: string) => void;
+    clearRipples: () => void;
+    getRippleStyle: (ripple: RippleEffect) => {
+        position: "absolute";
+        left: string;
+        top: string;
+        width: string;
+        height: string;
+        borderRadius: string;
+        backgroundColor: string;
+        transform: string;
+        animation: string;
+        pointerEvents: "none";
+        zIndex: number;
+    };
+    createRipple: (event: MouseEvent | TouchEvent) => void;
+    addRippleEffect: () => (() => void) | undefined;
+    removeRippleEffect: () => void;
+};
+export {};

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

@@ -0,0 +1,10 @@
+export declare function resetTheme(): void;
+export declare function useTheme(): {
+    isDark: import('vue').Ref<boolean, boolean>;
+    currentTheme: import('vue').ComputedRef<"dark" | "light">;
+    toggle: () => void;
+    setTheme: (theme: "light" | "dark") => void;
+    setDark: () => void;
+    setLight: () => void;
+    initTheme: () => void;
+};

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

@@ -0,0 +1,14 @@
+export declare const required: (value: any) => boolean;
+export declare const email: (value: any) => boolean;
+export declare const minLength: (min: number) => (value: any) => boolean;
+export declare const maxLength: (max: number) => (value: any) => boolean;
+export declare const pattern: (regex: RegExp) => (value: any) => boolean;
+export declare const custom: (validator: (value: any) => boolean) => (value: any) => boolean;
+export declare function useValidation(): {
+    required: (value: any) => boolean;
+    email: (value: any) => boolean;
+    minLength: (min: number) => (value: any) => boolean;
+    maxLength: (max: number) => (value: any) => boolean;
+    pattern: (regex: RegExp) => (value: any) => boolean;
+    custom: (validator: (value: any) => boolean) => (value: any) => boolean;
+};

package/dist/src/index.d.ts

@@ -0,0 +1,53 @@
+export { default as DatametriaButton } from './components/DatametriaButton.vue';
+export { default as DatametriaInput } from './components/DatametriaInput.vue';
+export { default as DatametriaPasswordInput } from './components/DatametriaPasswordInput.vue';
+export { default as DatametriaSelect } from './components/DatametriaSelect.vue';
+export { default as DatametriaCheckbox } from './components/DatametriaCheckbox.vue';
+export { default as DatametriaRadio } from './components/DatametriaRadio.vue';
+export { default as DatametriaSwitch } from './components/DatametriaSwitch.vue';
+export { default as DatametriaTextarea } from './components/DatametriaTextarea.vue';
+export { default as DatametriaDatePicker } from './components/DatametriaDatePicker.vue';
+export { default as DatametriaTimePicker } from './components/DatametriaTimePicker.vue';
+export { default as DatametriaSlider } from './components/DatametriaSlider.vue';
+export { default as DatametriaFileUpload } from './components/DatametriaFileUpload.vue';
+export { default as DatametriaAutocomplete } from './components/DatametriaAutocomplete.vue';
+export { default as DatametriaCard } from './components/DatametriaCard.vue';
+export { default as DatametriaModal } from './components/DatametriaModal.vue';
+export { default as DatametriaContainer } from './components/DatametriaContainer.vue';
+export { default as DatametriaGrid } from './components/DatametriaGrid.vue';
+export { default as DatametriaDivider } from './components/DatametriaDivider.vue';
+export { default as DatametriaAlert } from './components/DatametriaAlert.vue';
+export { default as DatametriaToast } from './components/DatametriaToast.vue';
+export { default as DatametriaTooltip } from './components/DatametriaTooltip.vue';
+export { default as DatametriaSkeleton } from './components/DatametriaSkeleton.vue';
+export { default as DatametriaProgress } from './components/DatametriaProgress.vue';
+export { default as DatametriaSpinner } from './components/DatametriaSpinner.vue';
+export { default as DatametriaTable } from './components/DatametriaTable.vue';
+export { default as DatametriaSortableTable } from './components/DatametriaSortableTable.vue';
+export { default as DatametriaAvatar } from './components/DatametriaAvatar.vue';
+export { default as DatametriaBadge } from './components/DatametriaBadge.vue';
+export { default as DatametriaChip } from './components/DatametriaChip.vue';
+export { default as DatametriaNavbar } from './components/DatametriaNavbar.vue';
+export { default as DatametriaSidebar } from './components/DatametriaSidebar.vue';
+export { default as DatametriaFloatingBar } from './components/DatametriaFloatingBar.vue';
+export { default as DatametriaMenu } from './components/DatametriaMenu.vue';
+export { default as DatametriaBreadcrumb } from './components/DatametriaBreadcrumb.vue';
+export { default as DatametriaTabs } from './components/DatametriaTabs.vue';
+export { useValidation, required, email, minLength, maxLength, pattern, custom } from './composables/useValidation';
+export { useAPI } from './composables/useAPI';
+export { useAccessibilityScale } from './composables/useAccessibilityScale';
+export { useBreakpoints } from './composables/useBreakpoints';
+export { useRipple } from './composables/useRipple';
+export { useHapticFeedback } from './composables/useHapticFeedback';
+export { useLocalStorage } from './composables/useLocalStorage';
+export { useDebounce } from './composables/useDebounce';
+export { useClipboard } from './composables/useClipboard';
+export { default as ThemeProvider } from './theme/ThemeProvider.vue';
+export { useTheme } from './theme/useTheme';
+export { datametriaTheme, defaultTheme } from './theme/presets';
+export type { Theme, ThemeTokens } from './theme/types';
+export type ButtonVariant = 'primary' | 'secondary' | 'tertiary' | 'outline';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+export type AlertVariant = 'info' | 'success' | 'warning' | 'error';
+export type BadgeVariant = 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+export type BadgeSize = 'sm' | 'md' | 'lg';