@webitel/ui-datalist 1.0.13 → 1.0.15

package/types/modules/filters/modules/filterConfig/components/score/score-from-to-filter-value-field.vue.d.ts

@@ -0,0 +1,20 @@
+type ModelValue = {
+    from: number;
+    to: number;
+};
+type __VLS_Props = {
+    numberMax?: number;
+};
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue?: ModelValue;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: ModelValue) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: ModelValue) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {
+    numberMax: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/score/score-from-to-filter-value-preview.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    value: number[];
+};
+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, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/tag/tag-filter-value-field.vue.d.ts

@@ -0,0 +1,11 @@
+type __VLS_PublicProps = {
+    modelValue?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/tag/tag-filter-value-preview.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    value: string[];
+};
+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, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/talk-duration/talk-duration-filter-value-field.vue.d.ts

@@ -0,0 +1,12 @@
+import type { TalkDurationFilterModelValue } from './TalkDurationFilter.d.ts';
+type __VLS_PublicProps = {
+    modelValue?: TalkDurationFilterModelValue;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: TalkDurationFilterModelValue) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: TalkDurationFilterModelValue) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/talk-duration/talk-duration-filter-value-preview.vue.d.ts

@@ -0,0 +1,6 @@
+import type { TalkDurationFilterModelValue } from './TalkDurationFilter.d.ts';
+type __VLS_Props = {
+    value: TalkDurationFilterModelValue;
+};
+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, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/team/team-filter-value-field.vue.d.ts

@@ -0,0 +1,12 @@
+type ModelValue = number[];
+type __VLS_PublicProps = {
+    modelValue?: ModelValue;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: ModelValue) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: ModelValue) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/team/team-filter-value-preview.vue.d.ts

@@ -0,0 +1,6 @@
+import type { EngineAgentTeam } from 'webitel-sdk';
+type __VLS_Props = {
+    value: EngineAgentTeam[];
+};
+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, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/total-duration/total-duration-filter-value-field.vue.d.ts

@@ -0,0 +1,12 @@
+import type { TotalDurationFilterModelValue } from './TotalDurationFilter';
+type __VLS_PublicProps = {
+    modelValue?: TotalDurationFilterModelValue;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: TotalDurationFilterModelValue) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: TotalDurationFilterModelValue) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/total-duration/total-duration-filter-value-preview.vue.d.ts

@@ -0,0 +1,6 @@
+import type { TalkDurationFilterModelValue } from '../talk-duration/TalkDurationFilter';
+type __VLS_Props = {
+    value: TalkDurationFilterModelValue;
+};
+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, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/user/user-filter-value-field.vue.d.ts

@@ -0,0 +1,12 @@
+type ModelValue = number[];
+type __VLS_PublicProps = {
+    modelValue?: ModelValue;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: ModelValue) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: ModelValue) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/user/user-filter-value-preview.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    /**
+     * would be great to use generated type for this
+     * */
+    value: Record<string, unknown>[];
+};
+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, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/variable/variable-filter-value-field.vue.d.ts

@@ -0,0 +1,12 @@
+type ModelValue = string;
+type __VLS_PublicProps = {
+    modelValue?: ModelValue;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/variable/variable-filter-value-preview.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    value: string;
+};
+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, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/composables/booleanFilterToolkit.d.ts

@@ -0,0 +1,20 @@
+import { ModelRef, type Reactive, type Ref } from 'vue';
+import { BooleanFilterModelValue } from "../enums/options/BooleanFilterOptions";
+export declare const usePrettifyBooleanValuePreview: (value: Reactive<boolean>) => {
+    localeValue: Ref<string>;
+};
+export declare const useBooleanFilterValueValidation: <T extends BooleanFilterModelValue>(model: ModelRef<T>) => {
+    v$: Ref<import("@vuelidate/core").Validation<{
+        model: {
+            required: (v: T) => boolean;
+        };
+    }, {
+        model: ModelRef<T>;
+    }>, import("@vuelidate/core").Validation<{
+        model: {
+            required: (v: T) => boolean;
+        };
+    }, {
+        model: ModelRef<T>;
+    }>>;
+};

package/types/modules/filters/modules/filterConfig/composables/useFromToSecToPreviewTime.d.ts

@@ -0,0 +1,7 @@
+export declare const useFromToSecToPreviewTime: (value: {
+    from?: number | string | null;
+    to?: number | string | null;
+}) => {
+    from: import("vue").ComputedRef<string>;
+    to: import("vue").ComputedRef<string>;
+};

package/types/modules/filters/modules/filterConfig/enums/FilterOption.d.ts

@@ -0,0 +1,47 @@
+export declare const FilterOption: {
+    readonly Agent: "agent";
+    readonly AmdResult: "amdResult";
+    readonly Contact: "contact";
+    readonly CallDirection: "direction";
+    readonly Rated: "rated";
+    readonly Gateway: "gateway";
+    readonly Grantee: "grantee";
+    readonly HangupCause: "cause";
+    readonly Queue: "queue";
+    readonly RatedBy: "ratedBy";
+    readonly HasFile: "hasFile";
+    readonly Score: "score";
+    readonly Tag: "tag";
+    readonly TalkDuration: "talkDuration";
+    readonly Team: "team";
+    readonly TotalDuration: "totalDuration";
+    readonly HasTranscription: "hasTranscription";
+    readonly User: "user";
+    readonly Variable: "variable";
+    readonly CreatedAt: "createdAt";
+    readonly CaseStatus: "status";
+    readonly CaseSource: "source";
+    readonly CaseService: "service";
+    readonly CaseAuthor: "author";
+    readonly CaseReporter: "reporter";
+    readonly CaseImpacted: "impacted";
+    readonly CaseAssignee: "assignee";
+    readonly ContactGroup: "contactGroup";
+    readonly CasePriority: "priority";
+    readonly CaseCloseReasonGroups: "closeReasonGroups";
+    readonly Rating: "rating";
+    readonly CaseSla: "sla";
+    readonly CaseSlaCondition: "slaCondition";
+    readonly CaseReactionTime: "reactionTime";
+    readonly CaseResolutionTime: "resolutionTime";
+    readonly CaseActualReactionTime: "actualReactionTime";
+    readonly CaseActualResolutionTime: "actualResolutionTime";
+    readonly HasAttachment: "hasAttachment";
+};
+/**
+ *
+ * @description
+ * any custom lookup fields or type extensions
+ */
+export type CustomFilterOption = string;
+export type FilterOption = (typeof FilterOption)[keyof typeof FilterOption] | CustomFilterOption;

package/types/modules/filters/modules/filterConfig/enums/options/AMDResultOptions.d.ts

@@ -0,0 +1,7 @@
+import { FilterInitParams } from "../../../../classes/Filter";
+/**
+ * AMD Result to filter
+ * @enum
+ * @readonly
+ */
+export declare const AmdResultOptions: Array<FilterInitParams>;

package/types/modules/filters/modules/filterConfig/enums/options/BooleanFilterOptions.d.ts

@@ -0,0 +1,3 @@
+import { FilterEnumOption } from '../../../../classes/Filter';
+export declare const BooleanOptions: Array<FilterEnumOption>;
+export type BooleanFilterModelValue = boolean;

package/types/modules/filters/modules/filterConfig/enums/options/CallDirectionFilterOptions.d.ts

@@ -0,0 +1,7 @@
+import { CallDirection } from 'webitel-sdk';
+export type CallDirectionType = (typeof CallDirection)[keyof typeof CallDirection];
+export type DirectionOption = {
+    locale: [string, number];
+    value: CallDirectionType;
+};
+export declare const CallDirectionFilterOptions: readonly DirectionOption[];

package/types/modules/filters/modules/filterConfig/enums/options/CallHistoryTagFilterOptions.d.ts

@@ -0,0 +1,2 @@
+import { FilterEnumOption } from "../../../../classes/Filter";
+export declare const CallHistoryTagFilterOptions: Array<FilterEnumOption>;

package/types/modules/filters/modules/filterConfig/enums/options/HangupCauseFilterOptions.d.ts

@@ -0,0 +1,7 @@
+import { FilterInitParams } from "../../../../classes/Filter";
+/**
+ * Hangup causes to filter
+ * @enum
+ * @readonly
+ */
+export declare const HangupCauseOptions: Array<FilterInitParams>;

package/types/modules/filters/modules/filterConfig/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './classes/FilterConfig';
+import { createFilterConfig } from './classes/createFilterConfig';
+export { createFilterConfig };

package/types/modules/filters/modules/filterConfig/types/DynamicFilterPreviewComponent.d.ts

@@ -0,0 +1,7 @@
+import { IFilter } from '../../../classes/Filter';
+import { TFilterConfig } from './FilterConfig';
+export type DynamicFilterPreviewComponentProps = {
+    value: unknown;
+    filterConfig: TFilterConfig;
+    filter: IFilter;
+};

package/types/modules/filters/scripts/utils.d.ts

@@ -0,0 +1,5 @@
+import { FilterName } from "../classes/Filter";
+export declare const filterLabelToSnapshotKey: (name: FilterName) => string;
+export declare const filterValueToSnapshotKey: (name: FilterName) => string;
+export declare const filterNameFromSnapshotKey: (snapshotKey: string) => FilterName;
+export declare const filterValuePropFromSnapshotKey: (snapshotKey: string) => string;

package/types/modules/headers/createTableHeadersStore.d.ts

@@ -0,0 +1,30 @@
+export declare const createTableHeadersStore: (namespace: string, { headers: rawHeaders }: {
+    headers: any;
+}) => import("pinia").StoreDefinition<string, Pick<{
+    headers: import("vue").Ref<any, any>;
+    shownHeaders: import("vue").ComputedRef<any>;
+    fields: import("vue").ComputedRef<any>;
+    sort: import("vue").ComputedRef<string>;
+    updateShownHeaders: (value: any) => void;
+    updateSort: (column: any) => void;
+    setupPersistence: () => Promise<[PromiseSettledResult<void>, PromiseSettledResult<void>]>;
+    $reset: () => void;
+}, "headers">, Pick<{
+    headers: import("vue").Ref<any, any>;
+    shownHeaders: import("vue").ComputedRef<any>;
+    fields: import("vue").ComputedRef<any>;
+    sort: import("vue").ComputedRef<string>;
+    updateShownHeaders: (value: any) => void;
+    updateSort: (column: any) => void;
+    setupPersistence: () => Promise<[PromiseSettledResult<void>, PromiseSettledResult<void>]>;
+    $reset: () => void;
+}, "sort" | "shownHeaders" | "fields">, Pick<{
+    headers: import("vue").Ref<any, any>;
+    shownHeaders: import("vue").ComputedRef<any>;
+    fields: import("vue").ComputedRef<any>;
+    sort: import("vue").ComputedRef<string>;
+    updateShownHeaders: (value: any) => void;
+    updateSort: (column: any) => void;
+    setupPersistence: () => Promise<[PromiseSettledResult<void>, PromiseSettledResult<void>]>;
+    $reset: () => void;
+}, "setupPersistence" | "updateShownHeaders" | "updateSort" | "$reset">>;

package/types/modules/pagination/createTablePaginationStore.d.ts

@@ -0,0 +1,25 @@
+export declare const createTablePaginationStore: (namespace: string) => import("pinia").StoreDefinition<string, Pick<{
+    page: import("vue").Ref<number, number>;
+    size: import("vue").Ref<number, number>;
+    next: import("vue").Ref<boolean, boolean>;
+    updatePage: (newPage: number) => void;
+    updateSize: (newSize: number) => void;
+    setupPersistence: () => Promise<[PromiseSettledResult<void>, PromiseSettledResult<void>]>;
+    $reset: () => void;
+}, "page" | "size" | "next">, Pick<{
+    page: import("vue").Ref<number, number>;
+    size: import("vue").Ref<number, number>;
+    next: import("vue").Ref<boolean, boolean>;
+    updatePage: (newPage: number) => void;
+    updateSize: (newSize: number) => void;
+    setupPersistence: () => Promise<[PromiseSettledResult<void>, PromiseSettledResult<void>]>;
+    $reset: () => void;
+}, never>, Pick<{
+    page: import("vue").Ref<number, number>;
+    size: import("vue").Ref<number, number>;
+    next: import("vue").Ref<boolean, boolean>;
+    updatePage: (newPage: number) => void;
+    updateSize: (newSize: number) => void;
+    setupPersistence: () => Promise<[PromiseSettledResult<void>, PromiseSettledResult<void>]>;
+    $reset: () => void;
+}, "setupPersistence" | "$reset" | "updatePage" | "updateSize">>;

package/types/modules/persist/PersistedStorage.types.d.ts

@@ -0,0 +1,36 @@
+import { Ref, WatchOptions } from 'vue';
+export declare enum PersistedStorageType {
+    LocalStorage = "localStorage",
+    Route = "route"
+}
+export type PersistStorableValue = string;
+export type PersistableValue = PersistStorableValue | {
+    toString: () => PersistStorableValue;
+};
+export interface StorageLike {
+    getItem(key: string): Promise<PersistableValue | null>;
+    setItem(key: string, value: PersistableValue): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export interface PersistedPropertyConfig {
+    name: string;
+    value: Ref<PersistableValue>;
+    storages?: PersistedStorageType | PersistedStorageType[];
+    storagePath?: string;
+    startWatchManually?: boolean;
+    watchConfig?: WatchOptions;
+    onStore?: (save: ({ name, value, }: {
+        name: string;
+        value: PersistableValue;
+    }) => Promise<void>, { value, name }: {
+        value: any;
+        name: any;
+    }) => Promise<void>;
+    onRestore?: (restore: (name: string) => Promise<PersistableValue>, name: string) => Promise<void>;
+}
+export interface PersistedStorageController {
+    watch: () => void;
+    unwatch: () => void;
+    restore: () => Promise<void>;
+    reset: () => Promise<void>;
+}

package/types/modules/persist/useLocalStoragePersistedStorage.d.ts

@@ -0,0 +1,4 @@
+import { StorageLike } from './PersistedStorage.types.ts';
+export declare const useLocalStoragePersistedStorage: ({ storagePath, }: {
+    storagePath: string;
+}) => StorageLike;

package/types/modules/persist/usePersistedStorage.d.ts

@@ -0,0 +1,2 @@
+import { PersistedPropertyConfig, PersistedStorageController } from './PersistedStorage.types.ts';
+export declare const usePersistedStorage: ({ name, value, storages: configStorages, storagePath, startWatchManually, onStore, onRestore, }: PersistedPropertyConfig) => PersistedStorageController;

package/types/modules/persist/useRoutePersistedStorage.d.ts

@@ -0,0 +1,2 @@
+import { StorageLike } from './PersistedStorage.types.ts';
+export declare const useRoutePersistedStorage: () => StorageLike;

package/types/modules/table/createTableStore.store.d.ts

@@ -0,0 +1,5 @@
+import { TableStore, useTableStoreParams } from '../types/tableStore.types.ts';
+export declare const createTableStore: <Entity extends {
+    id: string;
+    etag?: string;
+}>(namespace: string, { apiModule, headers, disablePersistence }: useTableStoreParams<Entity>) => import("pinia").StoreDefinition<string, Pick<TableStore<Entity>, "sort" | "filtersManager" | "headers" | "shownHeaders" | "fields" | "page" | "size" | "next" | "isFiltersRestoring" | "dataList" | "error" | "isLoading" | "selected">, Pick<TableStore<Entity>, never>, Pick<TableStore<Entity>, "hasFilter" | "addFilter" | "updateFilter" | "deleteFilter" | "updateShownHeaders" | "updateSort" | "updatePage" | "updateSize" | "updateSelected" | "loadDataList" | "initialize" | "deleteEls" | "patchItemProperty">>;

package/types/modules/types/tableStore.types.d.ts

@@ -0,0 +1,41 @@
+import { ApiModule } from '@webitel/ui-sdk/api/types/ApiModule.type.ts';
+import type { Ref } from 'vue';
+import { IFiltersManager } from '../filters';
+export interface useTableStoreParams<Entity> {
+    apiModule: ApiModule<Entity>;
+    headers: [];
+    disablePersistence?: boolean | [];
+}
+export interface PatchItemPropertyParams {
+    index: number;
+    path: string;
+    value: unknown;
+}
+export interface TableStore<Entity> {
+    dataList: Ref<Entity[]>;
+    selected: Ref<Entity[]>;
+    error: Ref<Error | null>;
+    isLoading: Ref<boolean>;
+    page: Ref<number>;
+    size: Ref<number>;
+    next: Ref<boolean>;
+    headers: Ref<[]>;
+    shownHeaders: Ref<[]>;
+    fields: Ref<[]>;
+    sort: Ref<string>;
+    filtersManager: Ref<IFiltersManager>;
+    isFiltersRestoring: Ref<boolean>;
+    initialize: () => Promise<void>;
+    loadDataList: (query?: object) => Promise<void>;
+    updateSelected: (selected: Entity[]) => void;
+    patchItemProperty: (payload: PatchItemPropertyParams) => Promise<void>;
+    deleteEls: (deleted: Entity[]) => Promise<void>;
+    updatePage: (page: number) => void;
+    updateSize: (size: number) => void;
+    updateSort: (column: object) => void;
+    updateShownHeaders: () => void;
+    hasFilter: IFiltersManager['hasFilter'];
+    addFilter: IFiltersManager['addFilter'];
+    updateFilter: IFiltersManager['updateFilter'];
+    deleteFilter: IFiltersManager['deleteFilter'];
+}