@webitel/ui-datalist 26.8.7 → 26.8.9

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

@@ -7,16 +7,16 @@ declare class TeamFilterConfig extends WtSysTypeFilterConfig {
     } & {
         modelValue?: number[];
     }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        "update:modelValue": (value: number[] | undefined) => any;
         "update:invalid": (args_0: boolean) => any;
+        "update:modelValue": (value: number[] | undefined) => any;
     }, string, import("vue").PublicProps, Readonly<{
         filterConfig: WtSysTypeFilterConfig;
         disableValidation?: boolean;
     } & {
         modelValue?: number[];
     }> & Readonly<{
-        "onUpdate:modelValue"?: ((value: number[] | undefined) => any) | undefined;
         "onUpdate:invalid"?: ((args_0: boolean) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: number[] | undefined) => any) | undefined;
     }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
     valuePreviewComponent: import("vue").DefineComponent<{
         value: EngineAgentTeam[];

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

@@ -9,11 +9,11 @@ type __VLS_ModelProps = {
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: ModelValue | undefined) => any;
     "update:invalid": (args_0: boolean) => any;
+    "update:modelValue": (value: ModelValue | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: ModelValue | undefined) => any) | undefined;
     "onUpdate:invalid"?: ((args_0: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: ModelValue | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -3,11 +3,11 @@ type __VLS_ModelProps = {
     modelValue?: TotalDurationFilterModelValue;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: TotalDurationFilterModelValue | undefined) => any;
     "update:invalid": (args_0: boolean) => any;
+    "update:modelValue": (value: TotalDurationFilterModelValue | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: TotalDurationFilterModelValue | undefined) => any) | undefined;
     "onUpdate:invalid"?: ((args_0: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: TotalDurationFilterModelValue | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,13 +1,17 @@
 type ModelValue = number[];
+type __VLS_Props = {
+    disableValidation?: boolean;
+};
 type __VLS_ModelProps = {
     modelValue?: ModelValue;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: ModelValue | undefined) => any;
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:invalid": (args_0: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: ModelValue | undefined) => any) | undefined;
+    "update:modelValue": (value: ModelValue | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:invalid"?: ((args_0: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: ModelValue | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -8,11 +8,11 @@ type __VLS_ModelProps = {
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string | undefined) => any;
     "update:invalid": (args_0: boolean) => any;
+    "update:modelValue": (value: string | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
     "onUpdate:invalid"?: ((args_0: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,13 +1,17 @@
 type ModelValue = string;
+type __VLS_Props = {
+    disableValidation?: boolean;
+};
 type __VLS_ModelProps = {
     modelValue?: ModelValue;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string | undefined) => any;
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:invalid": (args_0: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:invalid"?: ((args_0: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -15,6 +15,10 @@ export declare const tableHeadersStoreBody: ({ rawHeaders, id, }: TableHeadersSt
         sort?: (WtTableSortOrder | boolean) | undefined;
         show?: boolean | undefined;
         reorderable?: boolean | undefined;
+        filter?: string | {
+            name: string;
+        } | undefined;
+        filtered?: boolean | undefined;
         shouldBeInitialized?: boolean | undefined;
         access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
     }[], DatalistTableHeader[] | {
@@ -26,6 +30,10 @@ export declare const tableHeadersStoreBody: ({ rawHeaders, id, }: TableHeadersSt
         sort?: (WtTableSortOrder | boolean) | undefined;
         show?: boolean | undefined;
         reorderable?: boolean | undefined;
+        filter?: string | {
+            name: string;
+        } | undefined;
+        filtered?: boolean | undefined;
         shouldBeInitialized?: boolean | undefined;
         access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
     }[]>;
@@ -38,6 +46,10 @@ export declare const tableHeadersStoreBody: ({ rawHeaders, id, }: TableHeadersSt
         sort?: (WtTableSortOrder | boolean) | undefined;
         show?: boolean | undefined;
         reorderable?: boolean | undefined;
+        filter?: string | {
+            name: string;
+        } | undefined;
+        filtered?: boolean | undefined;
         shouldBeInitialized?: boolean | undefined;
         access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
     }[]>;
@@ -72,6 +84,10 @@ export declare const createTableHeadersStore: <Entity extends Identifiable>(name
         sort?: (WtTableSortOrder | boolean) | undefined;
         show?: boolean | undefined;
         reorderable?: boolean | undefined;
+        filter?: string | {
+            name: string;
+        } | undefined;
+        filtered?: boolean | undefined;
         shouldBeInitialized?: boolean | undefined;
         access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
     }[], DatalistTableHeader[] | {
@@ -83,6 +99,10 @@ export declare const createTableHeadersStore: <Entity extends Identifiable>(name
         sort?: (WtTableSortOrder | boolean) | undefined;
         show?: boolean | undefined;
         reorderable?: boolean | undefined;
+        filter?: string | {
+            name: string;
+        } | undefined;
+        filtered?: boolean | undefined;
         shouldBeInitialized?: boolean | undefined;
         access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
     }[]>;
@@ -95,6 +115,10 @@ export declare const createTableHeadersStore: <Entity extends Identifiable>(name
         sort?: (WtTableSortOrder | boolean) | undefined;
         show?: boolean | undefined;
         reorderable?: boolean | undefined;
+        filter?: string | {
+            name: string;
+        } | undefined;
+        filtered?: boolean | undefined;
         shouldBeInitialized?: boolean | undefined;
         access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
     }[]>;

package/types/modules/permissions-page/stores/createPermissionsStore.d.ts

@@ -21,41 +21,8 @@ export declare const permissionsStoreBody: (namespace: string, config: useTableS
     page: import("vue").Ref<number, number>;
     size: import("vue").Ref<number, number>;
     next: import("vue").Ref<boolean, boolean>;
-    headers: import("vue").Ref<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
-    }[], import("../../..").DatalistTableHeader[] | {
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
-    }[]>;
-    shownHeaders: import("vue").ComputedRef<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
-    }[]>;
+    headers: import("vue").ComputedRef<import("../../..").DatalistTableHeader[]>;
+    shownHeaders: import("vue").ComputedRef<import("../../..").DatalistTableHeader[]>;
     fields: import("vue").ComputedRef<string[]>;
     sort: import("vue").ComputedRef<string | null>;
     columnWidths: import("vue").ComputedRef<Record<string, string>>;
@@ -191,41 +158,8 @@ export declare const createPermissionsStore: (namespace: string, config: Omit<us
     page: import("vue").Ref<number, number>;
     size: import("vue").Ref<number, number>;
     next: import("vue").Ref<boolean, boolean>;
-    headers: import("vue").Ref<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
-    }[], import("../../..").DatalistTableHeader[] | {
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
-    }[]>;
-    shownHeaders: import("vue").ComputedRef<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | import("vue").Ref<boolean>) | undefined;
-    }[]>;
+    headers: import("vue").ComputedRef<import("../../..").DatalistTableHeader[]>;
+    shownHeaders: import("vue").ComputedRef<import("../../..").DatalistTableHeader[]>;
     fields: import("vue").ComputedRef<string[]>;
     sort: import("vue").ComputedRef<string | null>;
     columnWidths: import("vue").ComputedRef<Record<string, string>>;

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

@@ -1,6 +1,7 @@
 import { type Ref } from 'vue';
+import type { FilterName } from '../filters';
 import type { Identifiable } from '../types/createDatalistStore.types';
-import type { LoadDataListOptions, PatchItemPropertyParams, useTableStoreConfig } from '../types/tableStore.types';
+import type { DatalistTableHeader, LoadDataListOptions, PatchItemPropertyParams, useTableStoreConfig } from '../types/tableStore.types';
 export declare const tableStoreBody: <Entity extends Identifiable>(namespace: string, config: useTableStoreConfig<Entity>) => {
     isStoreSetUp: Ref<boolean, boolean>;
     isNested: Ref<boolean, boolean>;
@@ -11,120 +12,87 @@ export declare const tableStoreBody: <Entity extends Identifiable>(namespace: st
     page: Ref<number, number>;
     size: Ref<number, number>;
     next: Ref<boolean, boolean>;
-    headers: Ref<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | Ref<boolean>) | undefined;
-    }[], import("../..").DatalistTableHeader[] | {
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | Ref<boolean>) | undefined;
-    }[]>;
-    shownHeaders: import("vue").ComputedRef<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | Ref<boolean>) | undefined;
-    }[]>;
+    headers: import("vue").ComputedRef<DatalistTableHeader[]>;
+    shownHeaders: import("vue").ComputedRef<DatalistTableHeader[]>;
     fields: import("vue").ComputedRef<string[]>;
     sort: import("vue").ComputedRef<string | null>;
     columnWidths: import("vue").ComputedRef<Record<string, string>>;
     searchMode: Ref<string, string>;
     filtersManager: Ref<{
         filters: Map<string, {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel | undefined;
             set: (data: import("../filters/classes/Filter").FilterData) => import("../filters").IFilter;
         }> & Omit<Map<string, import("../filters").IFilter>, keyof Map<any, any>>;
-        hasFilter: (name: import("../filters").FilterName) => boolean;
-        getFilter: (name: import("../filters").FilterName) => import("../filters").IFilter | undefined;
+        hasFilter: (name: FilterName) => boolean;
+        getFilter: (name: FilterName) => import("../filters").IFilter | undefined;
         addFilter: (params: import("../filters").FilterInitParams, payload?: object, config?: import("../filters").FilterInstanceConfig) => import("../filters").IFilter;
         updateFilter: ({ name, }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value?: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel;
         }) => import("../filters").IFilter;
         deleteFilter: ({ name }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
         }) => import("../filters").IFilter | undefined;
         toString: (options?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => string;
         fromString: (snapshotStr: string) => void;
         reset: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => void;
-        getAllKeys: () => import("../filters").FilterName[];
+        getAllKeys: () => FilterName[];
         getAllValues: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => {
-            [name: import("../filters").FilterName]: import("../filters").FilterValue;
+            [name: FilterName]: import("../filters").FilterValue;
         };
         getFiltersList: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => import("../filters").IFilter[];
     }, {
         filters: Map<string, {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel | undefined;
             set: (data: import("../filters/classes/Filter").FilterData) => import("../filters").IFilter;
         }> & Omit<Map<string, import("../filters").IFilter>, keyof Map<any, any>>;
-        hasFilter: (name: import("../filters").FilterName) => boolean;
-        getFilter: (name: import("../filters").FilterName) => import("../filters").IFilter | undefined;
+        hasFilter: (name: FilterName) => boolean;
+        getFilter: (name: FilterName) => import("../filters").IFilter | undefined;
         addFilter: (params: import("../filters").FilterInitParams, payload?: object, config?: import("../filters").FilterInstanceConfig) => import("../filters").IFilter;
         updateFilter: ({ name, }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value?: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel;
         }) => import("../filters").IFilter;
         deleteFilter: ({ name }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
         }) => import("../filters").IFilter | undefined;
         toString: (options?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => string;
         fromString: (snapshotStr: string) => void;
         reset: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => void;
-        getAllKeys: () => import("../filters").FilterName[];
+        getAllKeys: () => FilterName[];
         getAllValues: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => {
-            [name: import("../filters").FilterName]: import("../filters").FilterValue;
+            [name: FilterName]: import("../filters").FilterValue;
         };
         getFiltersList: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => import("../filters").IFilter[];
     }>;
     isFiltersRestoring: Ref<boolean, boolean>;
@@ -143,7 +111,7 @@ export declare const tableStoreBody: <Entity extends Identifiable>(namespace: st
     updateSearchMode: (newSearch: string) => void;
     updatePage: (newPage: number) => void;
     updateSize: (newSize: number) => void;
-    updateSort: (column: import("../..").DatalistTableHeader, options?: {
+    updateSort: (column: DatalistTableHeader, options?: {
         order?: import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder;
     } | import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder) => void;
     columnResize: ({ columnName, columnWidth, }: {
@@ -151,16 +119,16 @@ export declare const tableStoreBody: <Entity extends Identifiable>(namespace: st
         columnWidth: string;
     }) => void;
     columnReorder: (orderedFields: string[]) => void;
-    updateShownHeaders: (value: import("../..").DatalistTableHeader[]) => void;
-    hasFilter: (name: import("../filters").FilterName) => boolean;
+    updateShownHeaders: (value: DatalistTableHeader[]) => void;
+    hasFilter: (name: FilterName) => boolean;
     addFilter: (params: import("../filters").FilterInitParams, payload?: object, config?: import("../filters").FilterInstanceConfig) => import("../filters").IFilter;
     updateFilter: ({ name, }: {
-        name: import("../filters").FilterName;
+        name: FilterName;
         value?: import("../filters").FilterValue;
         label?: import("../filters").FilterLabel;
     }) => import("../filters").IFilter;
     deleteFilter: ({ name }: {
-        name: import("../filters").FilterName;
+        name: FilterName;
     }) => import("../filters").IFilter | undefined;
 };
 export declare const createTableStore: <Entity extends Identifiable>(namespace: string, config: useTableStoreConfig<Entity>) => import("../types/createDatalistStore.types").PatchableStoreFactory<{
@@ -173,120 +141,87 @@ export declare const createTableStore: <Entity extends Identifiable>(namespace:
     page: Ref<number, number>;
     size: Ref<number, number>;
     next: Ref<boolean, boolean>;
-    headers: Ref<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | Ref<boolean>) | undefined;
-    }[], import("../..").DatalistTableHeader[] | {
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | Ref<boolean>) | undefined;
-    }[]>;
-    shownHeaders: import("vue").ComputedRef<{
-        value: string;
-        locale?: string | (string | number | Record<string, unknown>)[] | undefined;
-        text?: string | undefined;
-        width?: string | undefined;
-        field: string;
-        sort?: (import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder | boolean) | undefined;
-        show?: boolean | undefined;
-        reorderable?: boolean | undefined;
-        shouldBeInitialized?: boolean | undefined;
-        access?: (() => boolean | Ref<boolean>) | undefined;
-    }[]>;
+    headers: import("vue").ComputedRef<DatalistTableHeader[]>;
+    shownHeaders: import("vue").ComputedRef<DatalistTableHeader[]>;
     fields: import("vue").ComputedRef<string[]>;
     sort: import("vue").ComputedRef<string | null>;
     columnWidths: import("vue").ComputedRef<Record<string, string>>;
     searchMode: Ref<string, string>;
     filtersManager: Ref<{
         filters: Map<string, {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel | undefined;
             set: (data: import("../filters/classes/Filter").FilterData) => import("../filters").IFilter;
         }> & Omit<Map<string, import("../filters").IFilter>, keyof Map<any, any>>;
-        hasFilter: (name: import("../filters").FilterName) => boolean;
-        getFilter: (name: import("../filters").FilterName) => import("../filters").IFilter | undefined;
+        hasFilter: (name: FilterName) => boolean;
+        getFilter: (name: FilterName) => import("../filters").IFilter | undefined;
         addFilter: (params: import("../filters").FilterInitParams, payload?: object, config?: import("../filters").FilterInstanceConfig) => import("../filters").IFilter;
         updateFilter: ({ name, }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value?: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel;
         }) => import("../filters").IFilter;
         deleteFilter: ({ name }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
         }) => import("../filters").IFilter | undefined;
         toString: (options?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => string;
         fromString: (snapshotStr: string) => void;
         reset: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => void;
-        getAllKeys: () => import("../filters").FilterName[];
+        getAllKeys: () => FilterName[];
         getAllValues: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => {
-            [name: import("../filters").FilterName]: import("../filters").FilterValue;
+            [name: FilterName]: import("../filters").FilterValue;
         };
         getFiltersList: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => import("../filters").IFilter[];
     }, {
         filters: Map<string, {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel | undefined;
             set: (data: import("../filters/classes/Filter").FilterData) => import("../filters").IFilter;
         }> & Omit<Map<string, import("../filters").IFilter>, keyof Map<any, any>>;
-        hasFilter: (name: import("../filters").FilterName) => boolean;
-        getFilter: (name: import("../filters").FilterName) => import("../filters").IFilter | undefined;
+        hasFilter: (name: FilterName) => boolean;
+        getFilter: (name: FilterName) => import("../filters").IFilter | undefined;
         addFilter: (params: import("../filters").FilterInitParams, payload?: object, config?: import("../filters").FilterInstanceConfig) => import("../filters").IFilter;
         updateFilter: ({ name, }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
             value?: import("../filters").FilterValue;
             label?: import("../filters").FilterLabel;
         }) => import("../filters").IFilter;
         deleteFilter: ({ name }: {
-            name: import("../filters").FilterName;
+            name: FilterName;
         }) => import("../filters").IFilter | undefined;
         toString: (options?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => string;
         fromString: (snapshotStr: string) => void;
         reset: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => void;
-        getAllKeys: () => import("../filters").FilterName[];
+        getAllKeys: () => FilterName[];
         getAllValues: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => {
-            [name: import("../filters").FilterName]: import("../filters").FilterValue;
+            [name: FilterName]: import("../filters").FilterValue;
         };
         getFiltersList: ({ include, exclude, }?: {
-            include?: import("../filters").FilterName[];
-            exclude?: import("../filters").FilterName[];
+            include?: FilterName[];
+            exclude?: FilterName[];
         }) => import("../filters").IFilter[];
     }>;
     isFiltersRestoring: Ref<boolean, boolean>;
@@ -305,7 +240,7 @@ export declare const createTableStore: <Entity extends Identifiable>(namespace:
     updateSearchMode: (newSearch: string) => void;
     updatePage: (newPage: number) => void;
     updateSize: (newSize: number) => void;
-    updateSort: (column: import("../..").DatalistTableHeader, options?: {
+    updateSort: (column: DatalistTableHeader, options?: {
         order?: import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder;
     } | import("@webitel/ui-sdk/src/components/wt-table/types/WtTable").WtTableSortOrder) => void;
     columnResize: ({ columnName, columnWidth, }: {
@@ -313,15 +248,15 @@ export declare const createTableStore: <Entity extends Identifiable>(namespace:
         columnWidth: string;
     }) => void;
     columnReorder: (orderedFields: string[]) => void;
-    updateShownHeaders: (value: import("../..").DatalistTableHeader[]) => void;
-    hasFilter: (name: import("../filters").FilterName) => boolean;
+    updateShownHeaders: (value: DatalistTableHeader[]) => void;
+    hasFilter: (name: FilterName) => boolean;
     addFilter: (params: import("../filters").FilterInitParams, payload?: object, config?: import("../filters").FilterInstanceConfig) => import("../filters").IFilter;
     updateFilter: ({ name, }: {
-        name: import("../filters").FilterName;
+        name: FilterName;
         value?: import("../filters").FilterValue;
         label?: import("../filters").FilterLabel;
     }) => import("../filters").IFilter;
     deleteFilter: ({ name }: {
-        name: import("../filters").FilterName;
+        name: FilterName;
     }) => import("../filters").IFilter | undefined;
 }>;