v-sistec-features 1.31.13 → 1.32.0

package/dist/DataPageVue/components/VDataPage.vue.d.ts

@@ -0,0 +1,50 @@
+import { VDataPageProps, ExposedFunctions } from '../types/v-data-page.ts';
+declare const _default: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onTradePage?: ((...args: any[]) => any) | undefined;
+        readonly onBeforeFetch?: ((...args: any[]) => any) | undefined;
+        readonly onAfterFetch?: ((...args: any[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onTradePage" | "onBeforeFetch" | "onAfterFetch"> & VDataPageProps & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<ExposedFunctions>): void;
+    attrs: any;
+    slots: {
+        loading?(_: {
+            n: number;
+            index: number;
+        }): any;
+        loading?(_: {
+            index: number;
+        }): any;
+        error?(_: {
+            error: any;
+        }): any;
+        empty?(_: {}): any;
+        body?(_: {
+            item: T;
+            index: number;
+        }): any;
+        body?(_: {
+            item: T;
+            index: number;
+        }): any;
+        'scroll-finish'?(_: {}): any;
+        pagination?(_: {
+            pagination: {
+                current_page: number;
+                count: number;
+                limit_per_page: number;
+                search: string;
+                filter: string;
+            };
+            tradePage: () => Promise<void>;
+            error: any;
+        }): any;
+    };
+    emit: (event: "tradePage" | "beforeFetch" | "afterFetch", ...args: any[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/DataPageVue/index.d.ts

@@ -0,0 +1,2 @@
+import { default as VDataPage } from './components/VDataPage.vue';
+export { VDataPage };

package/dist/DataPageVue/types/v-data-page.d.ts

@@ -0,0 +1,53 @@
+import { Ref, Component, WatchSource, MaybeRefOrGetter } from 'vue';
+export interface VDataPageProps {
+    fetch: Function;
+    fetch_name?: string;
+    endpoint: string;
+    type_loading?: 'placeholder' | 'spiner-table' | 'spiner';
+    type_fetch?: 'pagination' | 'infinite-scroll' | 'none';
+    custom_loading?: Component | null;
+    deactivate_default_params?: boolean;
+    filter_param_name?: string;
+    search_param_name?: string;
+    page_param_name?: string;
+    page_size_param_name?: string;
+    add_params?: Object | Function;
+    data_key?: string;
+    total_key?: string;
+    list_filter?: any[];
+    first_text_page_size?: string;
+    second_text_page_size?: string;
+    class_container?: string;
+    class_loading_container?: string;
+    class_pagination?: string;
+    class_filters?: string;
+    min_loading_delay?: number;
+    retry_attempts?: number;
+    retry_delay?: number;
+    use_checkbox?: boolean;
+    item_key?: string;
+    limit_per_page?: number;
+    next_page_response_name?: string;
+    page_starts_at?: number;
+    element_id?: string;
+    watch?: WatchSource[];
+    disable_request?: MaybeRefOrGetter<boolean>;
+    pagination_teleport?: string | HTMLElement | null;
+}
+export interface PaginationObject {
+    current_page: number;
+    count: number;
+    limit_per_page: number;
+    search: string;
+    filter: string;
+}
+export interface ExposedFunctions {
+    execute: () => void;
+    pagination: Ref<PaginationObject>;
+    default_params: Record<string, any>;
+    set_limit_per_page: (newLimit: number) => void;
+    set_search: (newSearch: string) => void;
+    set_filter: (newFilter: string) => void;
+    set_page: (newPage: number) => void;
+    reSearch: () => void;
+}

package/dist/DatatableVue/components/SearchDatatable.vue.d.ts

@@ -0,0 +1,28 @@
+interface SearchProps {
+    search: string;
+    filter?: string;
+    list_filter?: any[];
+    item_use?: number[];
+    placeholder_search?: string;
+    deactivate_search_on_clear?: boolean;
+    deactivate_search_empty?: boolean;
+}
+declare const _default: import('vue').DefineComponent<SearchProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (...args: any[]) => void;
+    "update:search": (...args: any[]) => void;
+    "update:filter": (...args: any[]) => void;
+    clickedClearSearch: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<SearchProps> & Readonly<{
+    onSearch?: ((...args: any[]) => any) | undefined;
+    "onUpdate:search"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:filter"?: ((...args: any[]) => any) | undefined;
+    onClickedClearSearch?: ((...args: any[]) => any) | undefined;
+}>, {
+    list_filter: any[];
+    placeholder_search: string;
+    deactivate_search_empty: boolean;
+    deactivate_search_on_clear: boolean;
+    filter: string;
+    item_use: number[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/DatatableVue/components/VColumn.vue.d.ts

@@ -0,0 +1,82 @@
+import { Component } from 'vue';
+interface VColumnProps {
+    field?: string | null;
+    header: string;
+    type?: 'text' | 'img' | 'date' | 'html';
+    class_column?: string;
+    class_row?: string;
+    class_item?: string;
+    format?: 'complete' | 'simple';
+    deactivate_img_preview?: boolean;
+    limite_text?: number | string | null;
+    transform_function?: ((value: any) => any) | null;
+    click?: Function | null;
+    locked?: boolean | 'start' | 'end';
+    use_ordering?: boolean;
+    param_ordering?: string;
+    decreasing_value?: string;
+    increasing_value?: string;
+    class_rules?: Record<string, (item: any) => boolean>;
+    start_hidden?: boolean;
+    disable_hide?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        body?: (props: {
+            item: any;
+        }) => any;
+        col_header?: (props: {
+            col: any;
+            locked: boolean | "start" | "end";
+            OrderingComponent: Component;
+        }) => any;
+        col_header_midle?: (props: {
+            col: any;
+            locked: boolean | "start" | "end";
+        }) => any;
+    }> & {
+        body?: (props: {
+            item: any;
+        }) => any;
+        col_header?: (props: {
+            col: any;
+            locked: boolean | "start" | "end";
+            OrderingComponent: Component;
+        }) => any;
+        col_header_midle?: (props: {
+            col: any;
+            locked: boolean | "start" | "end";
+        }) => any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<VColumnProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VColumnProps> & Readonly<{}>, {
+    click: Function | null;
+    format: "complete" | "simple";
+    field: string | null;
+    type: "text" | "img" | "date" | "html";
+    class_column: string;
+    class_row: string;
+    class_item: string;
+    deactivate_img_preview: boolean;
+    limite_text: number | string | null;
+    transform_function: ((value: any) => any) | null;
+    locked: boolean | "start" | "end";
+    use_ordering: boolean;
+    param_ordering: string;
+    decreasing_value: string;
+    increasing_value: string;
+    class_rules: Record<string, (item: any) => boolean>;
+    start_hidden: boolean;
+    disable_hide: 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/DatatableVue/components/VColumnManager.vue.d.ts

@@ -0,0 +1,21 @@
+interface SearchProps {
+    columns_list?: any[];
+    use_column_manager?: boolean;
+    toggleColumnVisibility?: (columnId: string) => void;
+    class_column_manager_dropdown?: string;
+    class_column_manager_dropdown_menu?: string;
+    class_column_manager_button?: string;
+    disable_class_column_manager_default?: boolean;
+    resetColumnsState?: () => void;
+}
+declare const _default: import('vue').DefineComponent<SearchProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SearchProps> & Readonly<{}>, {
+    class_column_manager_dropdown: string;
+    class_column_manager_dropdown_menu: string;
+    class_column_manager_button: string;
+    disable_class_column_manager_default: boolean;
+    use_column_manager: boolean;
+    columns_list: any[];
+    toggleColumnVisibility: (columnId: string) => void;
+    resetColumnsState: () => void;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/DatatableVue/components/VDataTable.vue.d.ts

@@ -0,0 +1,57 @@
+import { VDataTableProps, ExposedFunctions } from '../types/v-data-table.ts';
+declare const _default: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onTradePage?: ((...args: any[]) => any) | undefined;
+        readonly onClickedClearSearch?: ((...args: any[]) => any) | undefined;
+        readonly onBeforeFetch?: ((...args: any[]) => any) | undefined;
+        readonly onAfterFetch?: ((...args: any[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onTradePage" | "onClickedClearSearch" | "onBeforeFetch" | "onAfterFetch"> & VDataTableProps & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<ExposedFunctions<T>>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+        pageSize?(_: {
+            changePageSize: (event: Event) => void;
+            limit_per_page: number;
+        }): any;
+        fieldMiddle?(_: {}): any;
+        'search-field'?(_: {
+            search: string;
+            filter: string;
+            reSearch: () => void;
+        }): any;
+        'extra-actions'?(_: {}): any;
+        'item-selected-info'?(_: {
+            selected_items: T[];
+            clearSelection: () => never[];
+        }): any;
+        'expand-button'?(_: {
+            item: T;
+            index: number;
+            isExpanded: boolean;
+            expand_item_toggle: (item: any) => void;
+        }): any;
+        'after-row'?(_: {
+            item: T;
+        }): any;
+        'idle-state'?(_: {}): any;
+        pagination?(_: {
+            pagination: {
+                current_page: number;
+                count: number;
+                limit_per_page: number;
+                search: string;
+                filter: string;
+            };
+            tradePage: () => Promise<void>;
+            error: any;
+        }): any;
+    };
+    emit: (event: "tradePage" | "clickedClearSearch" | "beforeFetch" | "afterFetch", ...args: any[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/DatatableVue/components/VDataTableLoading.vue.d.ts

@@ -0,0 +1,17 @@
+import { ColumnConfiguration } from '../keys';
+import { PaginationObject } from '../../DataPageVue/types/v-data-page.ts';
+interface AttemptObject {
+    current: number;
+    total: number;
+}
+type __VLS_Props = {
+    columns: ColumnConfiguration[];
+    limit: number;
+    type_loading: string;
+    custom_loading?: any;
+    class_table?: string;
+    attempt?: AttemptObject | null;
+    pagination: PaginationObject;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/DatatableVue/components/VOrderingIcon.vue.d.ts

@@ -0,0 +1,10 @@
+type __VLS_Props = {
+    orderings_state?: 'none' | 'increasing' | 'decreasing';
+    use_ordering?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggle: (args_0: void) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: ((args_0?: void | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/DatatableVue/components/VThDataTable.vue.d.ts

@@ -0,0 +1,14 @@
+type __VLS_Props = {
+    header: string;
+    class_column: string;
+    locked: boolean | 'start' | 'end';
+    use_ordering: boolean;
+    orderings_state: 'none' | 'increasing' | 'decreasing';
+    col: any;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggleOrderingState: (args_0: void) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggleOrderingState?: ((args_0?: void | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTableCellElement>;
+export default _default;

package/dist/DatatableVue/composables/useCheckBox.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { DataTablePropsWithDefaults } from '../types/v-data-table';
+export declare function useCheckBox<T extends Record<string, any>>(props: DataTablePropsWithDefaults, items: Ref<T[]>): {
+    selectAllCheckbox: Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    selected_items: Ref<T[], T[]>;
+    isSelected: (item: T) => boolean;
+    selectAllState: import('vue').ComputedRef<boolean | "indeterminate">;
+    atLeastOneSelected: import('vue').ComputedRef<boolean>;
+    toggleSelectAll: () => void;
+    toggleItemSelection: (item: T) => void;
+};

package/dist/DatatableVue/composables/useDataTableConfig.d.ts

@@ -0,0 +1,4 @@
+import { VDataTableProps, DataTablePropsWithDefaults } from '../types/v-data-table';
+export declare function useDataTableConfig(props: VDataTableProps): {
+    options: import('vue').ComputedRef<DataTablePropsWithDefaults>;
+};

package/dist/DatatableVue/composables/useDataTableFetch.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { PaginationObject, DataTablePropsWithDefaults } from '../types/v-data-table';
+import { ColumnConfiguration } from '../keys';
+export declare function useDataTableFetch<T extends Record<string, any>>(props: Ref<DataTablePropsWithDefaults>, pagination: Ref<PaginationObject>, columns: Ref<ColumnConfiguration[]>, orderings_state: Ref<Record<string, 'none' | 'increasing' | 'decreasing'>>, emit: (event: 'beforeFetch' | 'afterFetch') => void, close_all_expanded_items: () => void): {
+    items: import('vue').ComputedRef<T[]>;
+    pending: any;
+    error: any;
+    execute: any;
+    response: any;
+    attempt: any;
+    default_params: import('vue').ComputedRef<Record<string, any>>;
+    fetchDataWithDelay: () => Promise<void>;
+    reSearch: () => void;
+    showLoadingState: import('vue').ComputedRef<boolean>;
+    first_fetch: Ref<boolean, boolean>;
+    raw_items: Ref<T[], T[]>;
+};

package/dist/DatatableVue/composables/useExpandedItem.d.ts

@@ -0,0 +1,6 @@
+export declare function useExpandedItem(close_expanded_item_on_expand_new: boolean, item_key: string, deactivate_animation_expand?: boolean, scroll_to_expanded_item?: boolean): {
+    expanded_items: import('vue').Ref<any[], any[]>;
+    is_item_expanded: (item: any) => boolean;
+    expand_item_toggle: (item: any) => void;
+    close_all_expanded_items: () => void;
+};

package/dist/DatatableVue/composables/useImagePreview.d.ts

@@ -0,0 +1,9 @@
+import { CSSProperties } from 'vue';
+export declare function useImagePreview(): {
+    isHovering: import('vue').Ref<boolean, boolean>;
+    previewSrc: import('vue').Ref<string, string>;
+    previewStyle: import('vue').ComputedRef<CSSProperties>;
+    handleMouseOver: (event: MouseEvent, src: string) => void;
+    handleMouseMove: (event: MouseEvent) => void;
+    handleMouseLeave: () => void;
+};

package/dist/DatatableVue/config/datatableConfig.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey } from 'vue';
+import { VDataTableProps } from '../types/v-data-table';
+export type DataTableGlobalConfig = Partial<VDataTableProps>;
+export declare const DATA_TABLE_CONFIG: InjectionKey<DataTableGlobalConfig>;

package/dist/DatatableVue/config/datatableDefaults.d.ts

@@ -0,0 +1,7 @@
+import { VDataTableProps } from '../types/v-data-table';
+export type DataTableGlobalConfig = Partial<VDataTableProps>;
+/**
+ * nesse arquivo todas as props que não são obrigatórias ou seja que tem ?: definidas
+ * no typescript, são definidas aqui com valores default
+ * **/
+export declare const defaultDataTableConfig: DataTableGlobalConfig;

package/dist/DatatableVue/index.d.ts

@@ -0,0 +1,3 @@
+import { default as VColumn } from './components/VColumn.vue';
+import { default as VDataTable } from './components/VDataTable.vue';
+export { VDataTable, VColumn };

package/dist/DatatableVue/keys.d.ts

@@ -0,0 +1,39 @@
+import { InjectionKey, Slot } from 'vue';
+export interface ColumnConfiguration {
+    field: string | null;
+    header: string;
+    type: 'text' | 'img' | 'date' | 'html';
+    class_column: string;
+    class_row: string;
+    class_item: string;
+    transform_function: ((value: any) => any) | null;
+    bodySlot?: Slot;
+    colHeaderSlot?: Slot;
+    colHeaderMidleSlot?: Slot;
+    limite_text?: number;
+    deactivate_img_preview?: boolean;
+    format?: 'complete' | 'simple';
+    click: Function | null;
+    locked: boolean | 'start' | 'end';
+    use_ordering: boolean;
+    param_ordering: string;
+    decreasing_value: string;
+    increasing_value: string;
+    class_rules?: Record<string, (item: any) => boolean>;
+    start_hidden?: boolean;
+    visible?: boolean;
+    id: string;
+    storage_key?: string;
+    disable_hide?: boolean;
+}
+export interface DataTableApi {
+    addColumn: (config: ColumnConfiguration) => void;
+}
+export declare const dataTableApiKey: InjectionKey<DataTableApi>;
+export interface PaginationObject {
+    current_page: number;
+    count: number;
+    limit_per_page: number;
+    search: string;
+    filter: string;
+}

package/dist/DatatableVue/style/svgs.d.ts

@@ -0,0 +1,20 @@
+export declare const svgs: {
+    search: {
+        filter: string;
+        clear: string;
+        loupe: string;
+    };
+    checkbox: {
+        clear: string;
+    };
+    expand: {
+        arrow: string;
+        plus: string;
+    };
+    ordering: {
+        default: string;
+        decreasing: string;
+        increasing: string;
+    };
+    column_manager: string;
+};

package/dist/DatatableVue/types/v-data-table.d.ts

@@ -0,0 +1,161 @@
+import { Ref, ComputedRef, Component, MaybeRefOrGetter, DeepReadonly } from 'vue';
+import { PaginationObject } from '../keys';
+export type { PaginationObject } from '../keys';
+export interface ApiProps {
+    fetch: Function;
+    endpoint: string;
+    fetch_name?: string;
+    data_key?: string;
+    total_key?: string;
+    filter_param_name?: string;
+    search_param_name?: string;
+    page_param_name?: string;
+    page_size_param_name?: string;
+    add_params?: Record<string, any> | (() => Record<string, any>);
+    add_params_keep_page?: Record<string, any> | (() => Record<string, any>);
+    silent_params?: Record<string, any> | (() => Record<string, any>);
+    deactivate_default_params?: boolean;
+    disable_request?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * =====================================================
+ *  Tipagem para classes CSS.
+ *  Por que é usada: Agrupa as opções de estilização estrutural do datatable.
+ * =====================================================
+ * **/
+export interface ColumnManagerClass {
+    class_column_manager_dropdown?: string;
+    class_column_manager_dropdown_menu?: string;
+    class_column_manager_button?: string;
+    disable_class_column_manager_default?: boolean;
+}
+export interface PaginationClass {
+    class_pagination?: string;
+}
+export interface BodyClass {
+    class_content?: string;
+    class_container?: string;
+}
+export interface TableClass {
+    class_table?: string;
+}
+export interface FiltersClass {
+    class_filters?: string;
+    class_page_size?: string;
+}
+export type ClassProps = (ColumnManagerClass & PaginationClass & BodyClass & TableClass & FiltersClass);
+export interface BehaviorProps {
+    frontend_pagination?: boolean;
+    limit_per_page?: number;
+    page_starts_at?: number;
+    min_loading_delay?: number;
+    retry_attempts?: number;
+    retry_delay?: number;
+    immediate?: boolean;
+    storage_id?: string;
+    use_column_manager?: boolean;
+    show_header_when_empty?: boolean;
+    item_key?: string;
+    type_loading?: 'placeholder' | 'spiner-table' | 'spiner';
+    custom_loading?: Component | null;
+}
+export interface SearchProps {
+    list_filter?: any[];
+    placeholder_search?: string;
+    disable_search?: boolean;
+    deactivate_search_empty?: boolean;
+    deactivate_search_on_clear?: boolean;
+    custom_frontend_filter?: ((item: any, search: string, filter: string) => boolean) | null;
+}
+export interface PaginationProps {
+    first_text_page_size?: string;
+    second_text_page_size?: string;
+}
+export interface TeleportsProps {
+    search_teleport?: string | HTMLElement | null;
+    pagination_teleport?: string | HTMLElement | null;
+    extra_actions_teleport?: string | HTMLElement | null;
+    column_manager_teleport?: string | HTMLElement | null;
+}
+export interface ExtraFeaturesProps {
+    use_checkbox?: boolean;
+    deactivate_selected_info?: boolean;
+    use_expandable_items?: boolean;
+    close_expanded_item_on_expand_new?: boolean;
+    scroll_to_expanded_item?: boolean;
+    type_animation_expand?: 'fade' | 'expand' | 'none';
+    deactivate_animation_expand?: boolean;
+    type_button_expand?: 'arrow' | 'plus';
+}
+export type VDataTableProps = (ApiProps & ClassProps & BehaviorProps & SearchProps & PaginationProps & ExtraFeaturesProps & TeleportsProps);
+export type DataTablePropsWithDefaults = VDataTableProps & {
+    custom_frontend_filter: ((item: any, search: string, filter: string) => boolean) | null;
+    frontend_pagination: boolean;
+    fetch_name: string;
+    type_loading: string;
+    filter_param_name: string;
+    search_param_name: string;
+    page_param_name: string;
+    page_size_param_name: string;
+    data_key: string;
+    total_key: string;
+    item_key: string;
+    first_text_page_size: string;
+    second_text_page_size: string;
+    placeholder_search: string;
+    type_animation_expand: string;
+    type_button_expand: string;
+    class_table: string;
+    class_content: string;
+    class_container: string;
+    class_pagination: string;
+    class_filters: string;
+    class_page_size: string;
+    min_loading_delay: number;
+    retry_attempts: number;
+    retry_delay: number;
+    limit_per_page: number;
+    page_starts_at: number;
+    deactivate_default_params: boolean;
+    use_checkbox: boolean;
+    deactivate_selected_info: boolean;
+    immediate: boolean;
+    deactivate_search_on_clear: boolean;
+    use_expandable_items: boolean;
+    close_expanded_item_on_expand_new: boolean;
+    scroll_to_expanded_item: boolean;
+    deactivate_animation_expand: boolean;
+    deactivate_search_empty: boolean;
+    disable_request: MaybeRefOrGetter<boolean>;
+    add_params: Record<string, any> | (() => Record<string, any>);
+    list_filter: any[];
+    custom_loading: any | null;
+    storage_id: string;
+    use_column_manager: boolean;
+};
+export interface ExposedFunctions<T extends Record<string, any>> {
+    execute: () => void;
+    reSearch: () => void;
+    pagination: Ref<PaginationObject>;
+    default_params: Record<string, any>;
+    selected_items: Ref<T[]>;
+    atLeastOneSelected: ComputedRef<boolean>;
+    set_limit_per_page: (newLimit: number) => void;
+    set_search: (newSearch: string) => void;
+    set_filter: (newFilter: string) => void;
+    set_page: (newPage: number) => void;
+    expand_item_toggle: (item: any) => void;
+    close_all_expanded_items: () => void;
+    selectAllCheckbox: Ref<HTMLInputElement | null>;
+    toggleColumnVisibility: (field: string) => void;
+    columns_list: ComputedRef<Array<{
+        id: string;
+        header: string;
+        field: string | null;
+        start_hidden: boolean;
+        visible: boolean;
+        locked: boolean | 'start' | 'end';
+    }>>;
+    items: DeepReadonly<Ref<T[]>>;
+    results: DeepReadonly<Ref<T[]>>;
+}