@datametria/vue-components 2.2.0 → 2.3.0

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

@@ -1,28 +1,25 @@
-interface Option {
-    value: string | number;
-    label: string;
-    [key: string]: any;
-}
 interface Props {
-    modelValue?: string | number | Option | Option[];
-    options: (Option | string)[];
+    modelValue?: string;
+    fetchSuggestions: (query: string) => Promise<string[]> | string[];
+    debounce?: number;
+    triggerOnFocus?: boolean;
     placeholder?: string;
-    label?: string;
-    error?: string;
     disabled?: boolean;
-    required?: boolean;
-    loading?: boolean;
-    multiple?: boolean;
-    ariaLabel?: string;
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: string | number | Option | Option[]) => any;
+    select: (value: string) => any;
+    "update:modelValue": (value: string) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string | number | Option | Option[]) => any) | undefined;
+    onSelect?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
+    disabled: boolean;
+    modelValue: string;
     placeholder: string;
-    multiple: boolean;
+    debounce: number;
+    triggerOnFocus: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    autocompleteRef: HTMLDivElement;
+    inputRef: HTMLInputElement;
+    dropdownRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,16 +1,48 @@
-interface BreadcrumbItem {
+/**
+ * DatametriaBreadcrumb - Componente de navegação breadcrumb
+ *
+ * @component
+ * @example
+ * <DatametriaBreadcrumb
+ *   :items="[
+ *     { label: 'Home', to: '/' },
+ *     { label: 'Produtos', to: '/produtos' },
+ *     { label: 'Detalhes' }
+ *   ]"
+ *   separator="/"
+ * />
+ */
+export interface BreadcrumbItem {
+    /** Label do item */
     label: string;
-    href?: string;
+    /** Rota do Vue Router (opcional) */
+    to?: string | {
+        name: string;
+        params?: Record<string, any>;
+    };
 }
 interface Props {
+    /** Array de itens do breadcrumb */
     items: BreadcrumbItem[];
+    /** Separador entre itens */
     separator?: string;
 }
-declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    click: (item: BreadcrumbItem, index: number) => any;
-}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    onClick?: ((item: BreadcrumbItem, index: number) => any) | undefined;
-}>, {
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        separator?(_: {}): 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<{}>, {
     separator: string;
 }, {}, {}, {}, 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/DatametriaCheckbox.vue.d.ts

@@ -1,14 +1,43 @@
 interface Props {
-    modelValue?: boolean;
+    modelValue?: boolean | string | number;
     label?: string;
     disabled?: boolean;
+    indeterminate?: boolean;
+    trueValue?: boolean | string | number;
+    falseValue?: boolean | string | number;
 }
-declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: boolean) => any;
+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 | (string | number)[]) => any;
+    change: (value: string | number | boolean | (string | number)[]) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number | boolean | (string | number)[]) => any) | undefined;
+    onChange?: ((value: string | number | boolean | (string | number)[]) => any) | undefined;
 }>, {
     disabled: boolean;
-    modelValue: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+    modelValue: boolean | string | number;
+    indeterminate: boolean;
+    trueValue: boolean | string | number;
+    falseValue: boolean | string | number;
+}, {}, {}, {}, 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/DatametriaCheckboxGroup.vue.d.ts

@@ -0,0 +1,30 @@
+interface Props {
+    modelValue?: (string | number)[];
+    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)[]) => any;
+    change: (value: (string | number)[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+    onChange?: ((value: (string | number)[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: (string | 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/DatametriaDataTable.vue.d.ts

@@ -0,0 +1,64 @@
+interface Column {
+    prop: string;
+    label: string;
+    sortable?: boolean;
+    width?: string;
+    minWidth?: string;
+}
+interface Props {
+    data: any[];
+    columns: Column[];
+    loading?: boolean;
+    stripe?: boolean;
+    border?: boolean;
+    height?: string;
+    rowKey?: string;
+    selectable?: boolean;
+    multiple?: boolean;
+    expandable?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`cell-${string}`, (_: {
+        row: any;
+        column: Column;
+    }) => any>> & {
+        expand?(_: {
+            row: any;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    clearSelection: () => void;
+    toggleRowSelection: (row: any) => void;
+    clearSort: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "selection-change": (selection: any[]) => any;
+    "row-click": (row: any) => any;
+    "sort-change": (prop: string, order: "desc" | "asc") => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onSelection-change"?: ((selection: any[]) => any) | undefined;
+    "onRow-click"?: ((row: any) => any) | undefined;
+    "onSort-change"?: ((prop: string, order: "desc" | "asc") => any) | undefined;
+}>, {
+    loading: boolean;
+    data: any[];
+    multiple: boolean;
+    height: string;
+    border: boolean;
+    columns: Column[];
+    selectable: boolean;
+    stripe: boolean;
+    rowKey: string;
+    expandable: 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/DatametriaDatePicker.vue.d.ts

@@ -1,55 +1,33 @@
-type DateValue = string | {
-    start: string;
-    end: string;
-} | string[];
 interface Shortcut {
-    label: string;
-    value: string | {
-        start: string;
-        end: string;
-    } | string[];
+    text: string;
+    value: Date | [Date, Date];
 }
 interface Props {
-    modelValue?: DateValue;
-    mode?: 'single' | 'range' | 'multiple';
+    modelValue?: Date | [Date, Date] | null;
+    type?: 'date' | 'datetime' | 'range';
     format?: string;
     placeholder?: string;
-    label?: string;
-    errorMessage?: string;
     disabled?: boolean;
     readonly?: boolean;
-    required?: boolean;
-    min?: string;
-    max?: string;
-    disabledDates?: string[];
-    disabledWeekdays?: number[];
-    enabledDates?: string[];
-    showToday?: boolean;
-    clearable?: boolean;
-    closeOnSelect?: boolean;
-    showShortcuts?: boolean;
+    disabledDate?: (date: Date) => boolean;
     shortcuts?: Shortcut[];
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: DateValue) => any;
-    open: () => any;
-    close: () => any;
-    clear: () => any;
+    "update:modelValue": (value: Date | [Date, Date] | null) => any;
+    change: (value: Date | [Date, Date] | null) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: DateValue) => any) | undefined;
-    onOpen?: (() => any) | undefined;
-    onClose?: (() => any) | undefined;
-    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Date | [Date, Date] | null) => any) | undefined;
+    onChange?: ((value: Date | [Date, Date] | null) => any) | undefined;
 }>, {
+    disabled: boolean;
+    type: "date" | "datetime" | "range";
+    modelValue: Date | [Date, Date] | null;
     placeholder: string;
-    mode: "single" | "range" | "multiple";
+    readonly: boolean;
     format: string;
-    showToday: boolean;
-    clearable: boolean;
-    closeOnSelect: boolean;
-    showShortcuts: boolean;
     shortcuts: Shortcut[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    datepickerRef: HTMLDivElement;
+    inputRef: HTMLInputElement;
+    dropdownRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -0,0 +1,71 @@
+/**
+ * DatametriaDialog - Modal/Dialog reutilizável com slots customizáveis
+ *
+ * @component
+ * @example
+ * <DatametriaDialog v-model="visible" title="Título">
+ *   Conteúdo do dialog
+ * </DatametriaDialog>
+ */
+interface Props {
+    /** Controla visibilidade do dialog */
+    modelValue: boolean;
+    /** Título do dialog */
+    title?: string;
+    /** Largura do dialog (px, %, vw) */
+    width?: string | number;
+    /** Dialog em tela cheia */
+    fullscreen?: boolean;
+    /** Exibir overlay modal */
+    modal?: boolean;
+    /** Fechar ao clicar no overlay */
+    closeOnClickModal?: boolean;
+    /** Fechar ao pressionar ESC */
+    closeOnPressEscape?: boolean;
+    /** Exibir botão de fechar */
+    showClose?: boolean;
+    /** Centralizar conteúdo */
+    center?: boolean;
+    /** Callback antes de fechar */
+    beforeClose?: (done: () => void) => void;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    close: () => any;
+    open: () => any;
+    opened: () => any;
+    closed: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+}>, {
+    title: string;
+    width: string | number;
+    fullscreen: boolean;
+    modal: boolean;
+    closeOnClickModal: boolean;
+    closeOnPressEscape: boolean;
+    showClose: boolean;
+    center: 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/src/components/DatametriaEmpty.vue.d.ts

@@ -0,0 +1,30 @@
+interface Props {
+    description?: string;
+    image?: string;
+    imageAlt?: string;
+    imageType?: 'no-data' | 'no-results' | 'error';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        image?(_: {}): any;
+        description?(_: {}): 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<{}>, {
+    image: string;
+    description: string;
+    imageAlt: string;
+    imageType: "no-data" | "no-results" | "error";
+}, {}, {}, {}, 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/DatametriaFloatingBar.vue.d.ts

@@ -17,9 +17,9 @@ declare function __VLS_template(): {
 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" | "primary";
-    ariaLabel: string;
-    offset: string;
     position: "top" | "bottom" | "left" | "right";
+    offset: string;
+    ariaLabel: string;
     rounded: boolean;
     shadow: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;

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

@@ -0,0 +1,40 @@
+interface Props {
+    model?: Record<string, any>;
+    rules?: Record<string, any>;
+    labelWidth?: string;
+    labelPosition?: 'left' | 'right' | 'top';
+    inline?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLFormElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    validate: () => Promise<boolean>;
+    validateField: (prop: string) => Promise<boolean>;
+    resetFields: () => void;
+    clearValidate: (props?: string | string[]) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (model: Record<string, any>) => any;
+    validate: (valid: boolean, errors: Record<string, string[]>) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSubmit?: ((model: Record<string, any>) => any) | undefined;
+    onValidate?: ((valid: boolean, errors: Record<string, string[]>) => any) | undefined;
+}>, {
+    model: Record<string, any>;
+    rules: Record<string, any>;
+    labelPosition: "left" | "right" | "top";
+    inline: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLFormElement>;
+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/DatametriaFormItem.vue.d.ts

@@ -0,0 +1,28 @@
+interface Props {
+    prop?: string;
+    label?: string;
+    rules?: any[];
+    required?: 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, {
+    validate: () => Promise<boolean>;
+    reset: () => void;
+    clearValidate: () => void;
+    errorMessage: import('vue').Ref<string, string>;
+}, {}, {}, {}, 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/DatametriaGrid.vue.d.ts

@@ -12,8 +12,8 @@ declare function __VLS_template(): {
 };
 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<{}>, {
-    cols: number | string;
     gap: string;
+    cols: number | string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

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

@@ -1,18 +1,77 @@
+/**
+ * DatametriaInput - Input de texto com validação e slots
+ *
+ * @component
+ * @example
+ * <DatametriaInput v-model="value" placeholder="Digite algo" />
+ */
 interface Props {
-    modelValue?: string | number;
-    label?: string;
+    /** Valor do input */
+    modelValue: string | number;
+    /** Tipo do input */
+    type?: 'text' | 'password' | 'email' | 'number' | 'tel' | 'url';
+    /** Placeholder */
     placeholder?: string;
-    errorMessage?: string;
+    /** Input desabilitado */
     disabled?: boolean;
-    required?: boolean;
+    /** Input somente leitura */
+    readonly?: boolean;
+    /** Botão de limpar */
+    clearable?: boolean;
+    /** Comprimento máximo */
+    maxlength?: number;
+    /** Ícone prefixo */
+    prefixIcon?: string;
+    /** Ícone sufixo */
+    suffixIcon?: string;
+    /** Tamanho */
+    size?: 'small' | 'default' | 'large';
 }
-declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prepend?(_: {}): any;
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+        append?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (value: string | number) => any;
+    "update:modelValue": (value: string | number) => any;
+    change: (value: string | number) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    clear: () => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onInput?: ((value: string | number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+    onChange?: ((value: string | number) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onClear?: (() => any) | undefined;
 }>, {
+    size: "small" | "default" | "large";
     disabled: boolean;
-    modelValue: string | number;
-    required: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+    type: "text" | "password" | "email" | "number" | "tel" | "url";
+    placeholder: string;
+    readonly: boolean;
+    clearable: boolean;
+}, {}, {}, {}, 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;
+    };
+};

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

@@ -44,16 +44,16 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     toggle: () => void;
     isOpen: import('vue').ComputedRef<boolean>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    open: () => any;
     close: () => any;
+    open: () => any;
     "item-click": (item: MenuItem, index: number) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    onOpen?: (() => any) | undefined;
     onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
     "onItem-click"?: ((item: MenuItem, index: number) => any) | undefined;
 }>, {
-    placement: Placement;
     offset: number;
+    placement: Placement;
     items: MenuItem[];
     triggerText: string;
     showBackdrop: boolean;

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

@@ -19,10 +19,10 @@ declare function __VLS_template(): {
 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;
+    ariaLabel: string;
+    brand: string;
     bordered: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

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

@@ -0,0 +1,29 @@
+interface Props {
+    modelValue?: number;
+    total?: number;
+    pageSize?: number;
+    pageSizes?: number[];
+    layout?: string;
+    pagerCount?: number;
+    disabled?: boolean;
+    small?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+    "size-change": (size: number) => any;
+    "current-change": (page: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    "onSize-change"?: ((size: number) => any) | undefined;
+    "onCurrent-change"?: ((page: number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    small: boolean;
+    modelValue: number;
+    pageSize: number;
+    total: number;
+    pageSizes: number[];
+    layout: string;
+    pagerCount: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;