@datametria/vue-components 2.2.0 → 2.3.0

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

@@ -0,0 +1,43 @@
+type Placement = 'top' | 'bottom' | 'left' | 'right';
+interface Props {
+    title?: string;
+    confirmButtonText?: string;
+    cancelButtonText?: string;
+    placement?: Placement;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        popconfirmRef: HTMLDivElement;
+        triggerRef: HTMLDivElement;
+        popoverRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    confirm: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    title: string;
+    placement: Placement;
+    confirmButtonText: string;
+    cancelButtonText: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    popconfirmRef: HTMLDivElement;
+    triggerRef: HTMLDivElement;
+    popoverRef: 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/components/DatametriaProgress.vue.d.ts

@@ -1,12 +1,37 @@
+type ProgressType = 'line' | 'circle' | 'dashboard';
+type ProgressStatus = 'success' | 'warning' | 'error' | '';
 interface Props {
-    value: number;
-    label?: string;
-    variant?: 'primary' | 'success' | 'warning' | 'error';
-    showValue?: boolean;
-    ariaLabel?: string;
+    percentage?: number;
+    type?: ProgressType;
+    status?: ProgressStatus;
+    strokeWidth?: number;
+    showText?: boolean;
+    textInside?: boolean;
+    width?: number;
 }
-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;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): 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<{}>, {
+    type: ProgressType;
+    status: ProgressStatus;
+    width: number;
+    strokeWidth: number;
+    percentage: number;
+    showText: boolean;
+    textInside: 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/DatametriaRadio.vue.d.ts

@@ -1,17 +1,36 @@
 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, {
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string | number | boolean) => any;
+    change: (value: string | number | boolean) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: string | number | boolean) => any) | undefined;
+    onChange?: ((value: string | number | boolean) => any) | undefined;
 }>, {
     disabled: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, HTMLLabelElement>;
+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/DatametriaRadioGroup.vue.d.ts

@@ -0,0 +1,29 @@
+interface Props {
+    modelValue?: string | number | boolean;
+    disabled?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): 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": (value: string | number | boolean) => any;
+    change: (value: string | number | boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number | boolean) => any) | undefined;
+    onChange?: ((value: string | number | boolean) => any) | undefined;
+}>, {
+    disabled: 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/DatametriaResult.vue.d.ts

@@ -0,0 +1,30 @@
+type ResultStatus = 'success' | 'warning' | 'error' | 'info';
+interface Props {
+    status?: ResultStatus;
+    title?: string;
+    subtitle?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        title?(_: {}): any;
+        subtitle?(_: {}): any;
+        extra?(_: {}): 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<{}>, {
+    title: string;
+    status: ResultStatus;
+    subtitle: string;
+}, {}, {}, {}, 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/DatametriaSelect.vue.d.ts

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

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

@@ -21,18 +21,18 @@ 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;
+    open: () => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    onOpen?: (() => any) | undefined;
     onClose?: (() => any) | undefined;
     onToggle?: ((isOpen: boolean) => any) | undefined;
+    onOpen?: (() => any) | undefined;
 }>, {
     variant: "light" | "dark" | "primary";
     width: string;
-    ariaLabel: string;
     position: "left" | "right";
+    ariaLabel: string;
     collapsible: boolean;
     defaultOpen: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;

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

@@ -20,19 +20,19 @@ declare const _default: import('vue').DefineComponent<Props, {
 }, {}, {}, {}, 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;
+    blur: (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;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
 }>, {
+    step: number;
     min: number;
     max: number;
-    step: number;
     showValue: boolean;
     showMinMax: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {

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

@@ -16,9 +16,9 @@ declare const __VLS_component: import('vue').DefineComponent<SortableTableProps,
 }, string, import('vue').PublicProps, Readonly<SortableTableProps> & Readonly<{
     "onSelection-change"?: ((selectedIds: (string | number)[]) => any) | undefined;
 }>, {
+    filterable: boolean;
     selectable: boolean;
     searchable: boolean;
-    filterable: boolean;
     paginated: boolean;
     pageSize: number;
     pageSizeOptions: number[];

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

@@ -0,0 +1,45 @@
+/**
+ * DatametriaSteps - Componente de passos/wizard
+ *
+ * @component
+ * @example
+ * <DatametriaSteps
+ *   :active="1"
+ *   :items="[
+ *     { title: 'Passo 1', description: 'Descrição' },
+ *     { title: 'Passo 2' },
+ *     { title: 'Passo 3' }
+ *   ]"
+ *   direction="horizontal"
+ * />
+ */
+export interface StepItem {
+    /** Título do passo */
+    title: string;
+    /** Descrição do passo (opcional) */
+    description?: string;
+    /** Status customizado do passo */
+    status?: 'wait' | 'process' | 'finish' | 'error';
+}
+interface Props {
+    /** Índice do passo ativo (0-based) */
+    active?: number;
+    /** Array de itens dos passos */
+    items: StepItem[];
+    /** Direção dos passos */
+    direction?: 'horizontal' | 'vertical';
+    /** Modo simples (sem descrição) */
+    simple?: boolean;
+    /** Status global (sobrescreve status individual) */
+    status?: 'wait' | 'process' | 'finish' | 'error';
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (index: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onChange?: ((index: number) => any) | undefined;
+}>, {
+    direction: "horizontal" | "vertical";
+    active: number;
+    simple: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

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

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

@@ -0,0 +1,28 @@
+interface Props {
+    label: string;
+    name?: string;
+    disabled?: boolean;
+    lazy?: boolean;
+    icon?: string;
+    badge?: string | number;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): 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<{}>, {
+    disabled: boolean;
+    lazy: 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

@@ -1,22 +1,41 @@
 interface Props {
     modelValue?: string;
-    label?: string;
     placeholder?: string;
     disabled?: boolean;
-    required?: boolean;
-    error?: string;
+    readonly?: boolean;
     rows?: number;
-    maxLength?: number;
-    ariaLabel?: string;
+    maxlength?: number;
+    showWordLimit?: boolean;
+    autosize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
 }
-declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const _default: import('vue').DefineComponent<Props, {
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (value: string) => any;
     "update:modelValue": (value: string) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onInput?: ((value: string) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
 }>, {
     disabled: boolean;
     modelValue: string;
-    required: boolean;
+    placeholder: string;
+    readonly: boolean;
     rows: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+    showWordLimit: boolean;
+    autosize: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    textareaRef: HTMLTextAreaElement;
+}, HTMLDivElement>;
 export default _default;

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

@@ -1,36 +1,28 @@
 interface Props {
-    modelValue?: string;
-    label?: string;
+    modelValue?: string | null;
+    format?: string;
+    step?: number;
     placeholder?: string;
     disabled?: boolean;
-    required?: boolean;
-    errorMessage?: string;
-    successMessage?: string;
-    helperText?: string;
-    min?: string;
-    max?: string;
-    step?: number;
-    format24h?: boolean;
+    readonly?: boolean;
+    range?: 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;
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | null) => any;
+    change: (value: string | null) => 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;
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+    onChange?: ((value: string | null) => any) | undefined;
 }>, {
-    modelValue: string;
+    disabled: boolean;
+    modelValue: string | null;
+    placeholder: string;
+    readonly: boolean;
+    range: boolean;
+    format: string;
     step: number;
-    format24h: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     inputRef: HTMLInputElement;
+    dropdownRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -14,7 +14,7 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
 }>, {
     variant: "success" | "error" | "warning" | "info" | "primary";
     modelValue: boolean;
-    closable: boolean;
     duration: number;
+    closable: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -39,12 +39,12 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
 }>, {
     variant: Variant;
     maxWidth: string;
+    offset: number;
     placement: Placement;
     trigger: Trigger;
     showArrow: boolean;
     delay: number;
     hideDelay: number;
-    offset: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     triggerRef: HTMLDivElement;
     tooltipRef: HTMLDivElement;

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

@@ -0,0 +1,31 @@
+export interface TreeNode {
+    [key: string]: any;
+    children?: TreeNode[];
+}
+interface Props {
+    data: TreeNode[];
+    nodeKey?: string;
+    defaultExpandAll?: boolean;
+    checkable?: boolean;
+    defaultExpandedKeys?: (string | number)[];
+    defaultCheckedKeys?: (string | number)[];
+}
+declare const _default: import('vue').DefineComponent<Props, {
+    expandAll: () => void;
+    collapseAll: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    check: (checkedKeys: (string | number)[], node: TreeNode) => any;
+    nodeExpand: (node: TreeNode) => any;
+    nodeCollapse: (node: TreeNode) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCheck?: ((checkedKeys: (string | number)[], node: TreeNode) => any) | undefined;
+    onNodeExpand?: ((node: TreeNode) => any) | undefined;
+    onNodeCollapse?: ((node: TreeNode) => any) | undefined;
+}>, {
+    nodeKey: string;
+    checkable: boolean;
+    defaultExpandAll: boolean;
+    defaultExpandedKeys: (string | number)[];
+    defaultCheckedKeys: (string | number)[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,17 @@
+import { TreeNode } from './DatametriaTree.vue';
+interface Props {
+    node: TreeNode;
+    nodeKey: string;
+    checkable: boolean;
+    defaultExpandAll: boolean;
+    expandedKeys: Set<string | number>;
+    checkedKeys: Set<string | number>;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggle: (node: TreeNode) => any;
+    check: (node: TreeNode, checked: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onToggle?: ((node: TreeNode) => any) | undefined;
+    onCheck?: ((node: TreeNode, checked: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,64 @@
+interface UploadFile {
+    uid: string;
+    name: string;
+    size: number;
+    status: 'ready' | 'uploading' | 'success' | 'error';
+    progress: number;
+    preview?: string;
+    raw: File;
+}
+interface Props {
+    modelValue?: UploadFile[];
+    action?: string;
+    accept?: string;
+    multiple?: boolean;
+    limit?: number;
+    maxSize?: number;
+    drag?: boolean;
+    disabled?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {}): any;
+        trigger?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    clearFiles: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (files: UploadFile[]) => any;
+    change: (files: UploadFile[]) => any;
+    error: (error: Error, file: File) => any;
+    success: (response: any, file: UploadFile) => any;
+    exceed: (files: File[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((files: UploadFile[]) => any) | undefined;
+    onChange?: ((files: UploadFile[]) => any) | undefined;
+    onError?: ((error: Error, file: File) => any) | undefined;
+    onSuccess?: ((response: any, file: UploadFile) => any) | undefined;
+    onExceed?: ((files: File[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: UploadFile[];
+    multiple: boolean;
+    drag: boolean;
+    accept: string;
+    maxSize: number;
+    action: string;
+    limit: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};