@webitel/ui-datalist 1.0.14 → 1.0.15

package/types/modules/filters/components/config/dynamic-filter-config-form.vue.d.ts

@@ -0,0 +1,93 @@
+import { WtButton, WtSelect } from '@webitel/ui-sdk/components';
+import { FilterInitParams, IFilter } from "../../classes/Filter";
+import { BaseFilterConfig } from "../../modules/filterConfig/classes/FilterConfig";
+import DynamicFilterConfigFormLabel from './dynamic-filter-config-form-label.vue';
+import DynamicFilterConfigFormValueInput from "./dynamic-filter-config-form-value-input.vue";
+type __VLS_Props = {
+    /**
+     * @description
+     * "Add" mode
+     */
+    filterConfigs?: BaseFilterConfig[];
+    /**
+     * @description
+     * "Edit" mode
+     */
+    filterConfig?: BaseFilterConfig;
+    /**
+     * @description
+     * Edited filter instance
+     */
+    filter?: IFilter;
+};
+declare const emit: ((evt: "submit", args_0: FilterInitParams) => void) & ((evt: "cancel") => void);
+declare const t: import("vue-i18n").ComposerTranslation<{
+    [x: string]: import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType>;
+}, string, import("@intlify/core-base").RemoveIndexSignature<{
+    [x: string]: import("vue-i18n").LocaleMessageValue<import("vue-i18n").VueMessageType>;
+}>, never, never, never>;
+declare const filterName: import("vue").Ref<any, any>;
+declare const filterLabel: import("vue").Ref<string, string>;
+declare const filterValue: import("vue").Ref<any, any>;
+declare const editMode: boolean;
+declare const invalid: import("vue").Ref<boolean, boolean>;
+declare const filterConfigOptions: import("vue").ComputedRef<BaseFilterConfig[]>;
+declare const selectedFilterConfig: import("vue").ComputedRef<BaseFilterConfig>;
+declare const onValueChange: (v: any) => void;
+declare const onValueInvalidChange: (v: any) => void;
+declare const valueInputLabelText: import("vue").ComputedRef<string>;
+declare const onLabelValueUpdate: (val: string) => void;
+declare const onFilterNameUpdate: (val: string) => void;
+declare const submit: () => void;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_9: {
+    filterName: any;
+    filterValue: any;
+    inputLabel: string;
+    onValueChange: (v: any) => void;
+    onValueInvalidChange: (v: any) => void;
+};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    'value-input'?: (props: typeof __VLS_9) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<__VLS_Props, {
+    WtButton: typeof WtButton;
+    WtSelect: typeof WtSelect;
+    DynamicFilterConfigFormLabel: typeof DynamicFilterConfigFormLabel;
+    DynamicFilterConfigFormValueInput: typeof DynamicFilterConfigFormValueInput;
+    emit: typeof emit;
+    t: typeof t;
+    filterName: typeof filterName;
+    filterLabel: typeof filterLabel;
+    filterValue: typeof filterValue;
+    editMode: typeof editMode;
+    invalid: typeof invalid;
+    filterConfigOptions: typeof filterConfigOptions;
+    selectedFilterConfig: typeof selectedFilterConfig;
+    onValueChange: typeof onValueChange;
+    onValueInvalidChange: typeof onValueInvalidChange;
+    valueInputLabelText: typeof valueInputLabelText;
+    onLabelValueUpdate: typeof onLabelValueUpdate;
+    onFilterNameUpdate: typeof onFilterNameUpdate;
+    submit: typeof submit;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: (args_0: FilterInitParams) => any;
+    cancel: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSubmit?: (args_0: FilterInitParams) => any;
+    onCancel?: () => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: (args_0: FilterInitParams) => any;
+    cancel: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSubmit?: (args_0: FilterInitParams) => any;
+    onCancel?: () => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/modules/filters/components/config/dynamic-filter-config-view.vue.d.ts

@@ -0,0 +1,27 @@
+import { WtTooltip } from '@webitel/ui-sdk/components';
+interface Props {
+    disabled?: boolean;
+    disableClickAway?: boolean;
+}
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_5: {
+    tooltipSlotScope: any;
+}, __VLS_7: {
+    tooltipSlotScope: any;
+};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    activator?: (props: typeof __VLS_5) => any;
+} & {
+    content?: (props: typeof __VLS_7) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<Props, {
+    WtTooltip: typeof WtTooltip;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/modules/filters/components/dynamic-filter-add-action.vue.d.ts

@@ -0,0 +1,47 @@
+import { WtIconAction } from '@webitel/ui-sdk/components';
+import { FilterInitParams } from "../classes/Filter";
+import { BaseFilterConfig } from "../modules/filterConfig/classes/FilterConfig";
+import DynamicFilterConfigForm from './config/dynamic-filter-config-form.vue';
+import DynamicFilterConfigView from './config/dynamic-filter-config-view.vue';
+interface Props {
+    filterConfigs: BaseFilterConfig[];
+    showLabel?: boolean;
+}
+declare const t: import("vue-i18n").ComposerTranslation<{
+    [x: string]: import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType>;
+}, string, import("@intlify/core-base").RemoveIndexSignature<{
+    [x: string]: import("vue-i18n").LocaleMessageValue<import("vue-i18n").VueMessageType>;
+}>, never, never, never>;
+declare const submit: (payload: FilterInitParams, { hide }: {
+    hide: any;
+}) => void;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_9: {
+    tooltipSlotScope: any;
+};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    form?: (props: typeof __VLS_9) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<Props, {
+    WtIconAction: typeof WtIconAction;
+    DynamicFilterConfigForm: typeof DynamicFilterConfigForm;
+    DynamicFilterConfigView: typeof DynamicFilterConfigView;
+    t: typeof t;
+    submit: typeof submit;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "add:filter": (args_0: FilterInitParams) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onAdd:filter"?: (args_0: FilterInitParams) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "add:filter": (args_0: FilterInitParams) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onAdd:filter"?: (args_0: FilterInitParams) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/modules/filters/components/dynamic-filter-panel-wrapper.vue.d.ts

@@ -0,0 +1,24 @@
+import { ComponentSize } from '@webitel/ui-sdk/enums';
+type __VLS_Props = {
+    size?: ComponentSize;
+};
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    filters?: (props: typeof __VLS_1) => any;
+} & {
+    actions?: (props: typeof __VLS_3) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: ComponentSize;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: ComponentSize;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/modules/filters/components/preview/dynamic-filter-preview-info.vue.d.ts

@@ -0,0 +1,16 @@
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_1: {}, __VLS_7: {};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_7) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/modules/filters/components/preview/dynamic-filter-preview.vue.d.ts

@@ -0,0 +1,72 @@
+import { WtChip, WtIconBtn, WtLoader, WtTooltip } from '@webitel/ui-sdk/components';
+import { FilterData, IFilter } from "../../classes/Filter";
+import { TFilterConfig } from "../../modules/filterConfig/classes/FilterConfig";
+import DynamicFilterConfigForm from '../config/dynamic-filter-config-form.vue';
+import DynamicFilterConfigView from '../config/dynamic-filter-config-view.vue';
+import DynamicFilterPreviewInfo from './dynamic-filter-preview-info.vue';
+interface Props {
+    filter: IFilter;
+    /**
+     * @description
+     * this filter config
+     */
+    filterConfig: TFilterConfig;
+    readonly?: boolean;
+}
+declare const localValue: import("vue").Ref<any, any>;
+/**
+ * @author @dlohvinov
+ *
+ * @description
+ * loading filters preview data -> main preview component
+ * instead of tooltip-components to avoid api requests spam
+ */
+declare const fillLocalValue: (filter?: IFilter) => Promise<void>;
+declare const isRenderPreview: import("vue").ComputedRef<any>;
+declare const submit: (filter: IFilter, { hide }: {
+    hide: any;
+}) => void;
+declare const deleteFilter: () => void;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_28: {}, __VLS_38: {
+    tooltipSlotScope: any;
+};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    info?: (props: typeof __VLS_28) => any;
+} & {
+    form?: (props: typeof __VLS_38) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<Props, {
+    WtChip: typeof WtChip;
+    WtIconBtn: typeof WtIconBtn;
+    WtLoader: typeof WtLoader;
+    WtTooltip: typeof WtTooltip;
+    DynamicFilterConfigForm: typeof DynamicFilterConfigForm;
+    DynamicFilterConfigView: typeof DynamicFilterConfigView;
+    DynamicFilterPreviewInfo: typeof DynamicFilterPreviewInfo;
+    localValue: typeof localValue;
+    fillLocalValue: typeof fillLocalValue;
+    isRenderPreview: typeof isRenderPreview;
+    submit: typeof submit;
+    deleteFilter: typeof deleteFilter;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:filter": (args_0: FilterData) => any;
+    "delete:filter": (args_0: IFilter) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:filter"?: (args_0: FilterData) => any;
+    "onDelete:filter"?: (args_0: IFilter) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:filter": (args_0: FilterData) => any;
+    "delete:filter": (args_0: IFilter) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:filter"?: (args_0: FilterData) => any;
+    "onDelete:filter"?: (args_0: IFilter) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/modules/filters/components/search-bar/dynamic-filter-search.vue.d.ts

@@ -0,0 +1,22 @@
+import { FilterInitParams, FilterName } from "../../classes/Filter";
+import { IFiltersManager } from "../../classes/FiltersManager";
+import type { DynamicFilterSearchSearchModeOption } from './types/DynamicFilterSearch';
+type __VLS_Props = {
+    filtersManager: IFiltersManager;
+    searchModeOptions?: DynamicFilterSearchSearchModeOption[];
+    isFiltersRestoring?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "filter:add": (args_0: FilterInitParams) => any;
+    "filter:update": (args_0: FilterInitParams) => any;
+    "filter:delete": (args_0: {
+        name: FilterName;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onFilter:add"?: (args_0: FilterInitParams) => any;
+    "onFilter:update"?: (args_0: FilterInitParams) => any;
+    "onFilter:delete"?: (args_0: {
+        name: FilterName;
+    }) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/types/modules/filters/components/table-filters-panel.vue.d.ts

@@ -0,0 +1,65 @@
+import { Store } from 'pinia';
+import { WebitelProtoDataField } from "webitel-sdk";
+import { FilterData, IFilter } from "../classes/Filter";
+import { IFiltersManager } from "../classes/FiltersManager";
+import { TFilterConfig } from "../modules/filterConfig/classes/FilterConfig";
+import { FilterOption } from '../modules/filterConfig/enums/FilterOption';
+type Props = {
+    /**
+     * @description
+     * available filter options to set
+     */
+    filterOptions: (FilterOption | TFilterConfig)[];
+    /**
+     * @description
+     * create local filters manager from snapshot
+     * inside save-preset.vue
+     */
+    filtersManager: IFiltersManager;
+    /**
+     * @author @dlohvinov
+     *
+     * @implements
+     * [WTEL-6702](https://webitel.atlassian.net/browse/WTEL-6702)
+     *
+     * @description
+     * Decided to pass fields as a prop instead of converting them to
+     * Props.filterOptions, because this functionality can be expanded to many
+     * filter panels
+     */
+    filterableExtensionFields?: WebitelProtoDataField[];
+    /**
+     * @description
+     * QueryPreset "section" field
+     */
+    presetNamespace?: string;
+    /**
+     * @author @dlohvinov
+     *
+     * @description
+     * table store for operating with presets as dataList.
+     * Seems to me like a bad idea, because apply-preset should not store
+     * any data in a specific store – component state should be enough.
+     * However as for now, there's no composable implementing this logic,
+     * so store is used instead.
+     *
+     * TODO: https://github.com/webitel/webitel-ui-sdk/pull/551
+     */
+    usePresetsStore?: Store;
+};
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "filter:add": (args_0: FilterData) => any;
+    "filter:update": (args_0: FilterData) => any;
+    "filter:delete": (args_0: IFilter) => any;
+    hide: () => any;
+    "filter:reset-all": () => any;
+    "preset:apply": (args_0: string) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onFilter:add"?: (args_0: FilterData) => any;
+    "onFilter:update"?: (args_0: FilterData) => any;
+    "onFilter:delete"?: (args_0: IFilter) => any;
+    onHide?: () => any;
+    "onFilter:reset-all"?: () => any;
+    "onPreset:apply"?: (args_0: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/types/modules/filters/composables/useFilterConfigsToolkit.d.ts

@@ -0,0 +1,31 @@
+import { ComputedRef } from 'vue';
+import { WebitelProtoDataField } from 'webitel-sdk';
+import { FilterName, IFilter } from '../classes/Filter';
+import { IFiltersManager } from '../classes/FiltersManager';
+import { BaseFilterConfig } from '../modules/filterConfig/classes/FilterConfig';
+import { FilterOption } from '../modules/filterConfig/enums/FilterOption';
+export type FilterConfigToolkit = {
+    filterConfigs: ComputedRef<BaseFilterConfig[]>;
+    /**
+     * @description
+     * some filters may be stored in filtersManager,
+     * but not included in this filters panel
+     */
+    filtersIncluded: ComputedRef<FilterName[]>;
+    appliedFilters: ComputedRef<IFilter[]>;
+    /**
+     * @description
+     * available filters to add, with appliedFilters excluded
+     */
+    unAppliedFiltersConfigs: ComputedRef<BaseFilterConfig[]>;
+    appliedFilterToFilterConfigMappings: ComputedRef<Array<{
+        filterConfig: BaseFilterConfig;
+        filter: IFilter;
+    }>>;
+};
+export type FilterConfigToolkitParams = {
+    filterOptions: (FilterOption | BaseFilterConfig)[];
+    filtersManager: IFiltersManager;
+    filterableExtensionFields: WebitelProtoDataField[];
+};
+export declare const useFilterConfigsToolkit: ({ filterOptions, filtersManager, filterableExtensionFields, }: FilterConfigToolkitParams) => FilterConfigToolkit;

package/types/modules/filters/createTableFiltersStore.d.ts

@@ -0,0 +1,121 @@
+import { FiltersManagerConfig } from './classes/FiltersManager.ts';
+export declare const createTableFiltersStore: (namespace: string, config?: {
+    filtersManagerConfig: FiltersManagerConfig;
+}) => import("pinia").StoreDefinition<string, Pick<{
+    filtersManager: {
+        filters: Map<string, {
+            name: import("./index.js").FilterName;
+            value: import("./index.js").FilterValue;
+            label?: import("./index.js").FilterLabel;
+            set: (data: import("./classes/Filter.js").FilterData) => import("./index.js").IFilter;
+        }> & Omit<Map<string, import("./index.js").IFilter>, keyof Map<any, any>>;
+        hasFilter: (name: import("./index.js").FilterName) => boolean;
+        getFilter: (name: import("./index.js").FilterName) => import("./index.js").IFilter;
+        addFilter: (params: import("./index.js").FilterInitParams, payload?: object, config?: import("./index.js").FilterInstanceConfig) => import("./index.js").IFilter;
+        updateFilter: ({ name, }: {
+            name: import("./index.js").FilterName;
+            value?: import("./index.js").FilterValue;
+            label?: import("./index.js").FilterLabel;
+        }) => import("./index.js").IFilter;
+        deleteFilter: (name: import("./index.js").FilterName) => import("./index.js").IFilter;
+        toString: () => string;
+        fromString: (snapshotStr: string) => void;
+        reset: ({ include, exclude, }?: {
+            include?: import("./index.js").FilterName[];
+            exclude?: import("./index.js").FilterName[];
+        }) => void;
+        getAllKeys: () => import("./index.js").FilterName[];
+        getAllValues: () => {
+            [name: import("./index.js").FilterName]: import("./index.js").FilterValue;
+        };
+        getFiltersList: ({ include, exclude, }?: {
+            include?: import("./index.js").FilterName[];
+            exclude?: import("./index.js").FilterName[];
+        }) => import("./index.js").IFilter[];
+    };
+    isRestoring: import("vue").Ref<boolean, boolean>;
+    filtersList: import("vue").ComputedRef<import("./index.js").IFilter[]>;
+    hasFilter: any;
+    addFilter: any;
+    updateFilter: any;
+    deleteFilter: any;
+    setupPersistence: () => Promise<void>;
+}, "hasFilter" | "addFilter" | "updateFilter" | "deleteFilter" | "filtersManager" | "isRestoring">, Pick<{
+    filtersManager: {
+        filters: Map<string, {
+            name: import("./index.js").FilterName;
+            value: import("./index.js").FilterValue;
+            label?: import("./index.js").FilterLabel;
+            set: (data: import("./classes/Filter.js").FilterData) => import("./index.js").IFilter;
+        }> & Omit<Map<string, import("./index.js").IFilter>, keyof Map<any, any>>;
+        hasFilter: (name: import("./index.js").FilterName) => boolean;
+        getFilter: (name: import("./index.js").FilterName) => import("./index.js").IFilter;
+        addFilter: (params: import("./index.js").FilterInitParams, payload?: object, config?: import("./index.js").FilterInstanceConfig) => import("./index.js").IFilter;
+        updateFilter: ({ name, }: {
+            name: import("./index.js").FilterName;
+            value?: import("./index.js").FilterValue;
+            label?: import("./index.js").FilterLabel;
+        }) => import("./index.js").IFilter;
+        deleteFilter: (name: import("./index.js").FilterName) => import("./index.js").IFilter;
+        toString: () => string;
+        fromString: (snapshotStr: string) => void;
+        reset: ({ include, exclude, }?: {
+            include?: import("./index.js").FilterName[];
+            exclude?: import("./index.js").FilterName[];
+        }) => void;
+        getAllKeys: () => import("./index.js").FilterName[];
+        getAllValues: () => {
+            [name: import("./index.js").FilterName]: import("./index.js").FilterValue;
+        };
+        getFiltersList: ({ include, exclude, }?: {
+            include?: import("./index.js").FilterName[];
+            exclude?: import("./index.js").FilterName[];
+        }) => import("./index.js").IFilter[];
+    };
+    isRestoring: import("vue").Ref<boolean, boolean>;
+    filtersList: import("vue").ComputedRef<import("./index.js").IFilter[]>;
+    hasFilter: any;
+    addFilter: any;
+    updateFilter: any;
+    deleteFilter: any;
+    setupPersistence: () => Promise<void>;
+}, "hasFilter" | "addFilter" | "updateFilter" | "deleteFilter" | "filtersList">, Pick<{
+    filtersManager: {
+        filters: Map<string, {
+            name: import("./index.js").FilterName;
+            value: import("./index.js").FilterValue;
+            label?: import("./index.js").FilterLabel;
+            set: (data: import("./classes/Filter.js").FilterData) => import("./index.js").IFilter;
+        }> & Omit<Map<string, import("./index.js").IFilter>, keyof Map<any, any>>;
+        hasFilter: (name: import("./index.js").FilterName) => boolean;
+        getFilter: (name: import("./index.js").FilterName) => import("./index.js").IFilter;
+        addFilter: (params: import("./index.js").FilterInitParams, payload?: object, config?: import("./index.js").FilterInstanceConfig) => import("./index.js").IFilter;
+        updateFilter: ({ name, }: {
+            name: import("./index.js").FilterName;
+            value?: import("./index.js").FilterValue;
+            label?: import("./index.js").FilterLabel;
+        }) => import("./index.js").IFilter;
+        deleteFilter: (name: import("./index.js").FilterName) => import("./index.js").IFilter;
+        toString: () => string;
+        fromString: (snapshotStr: string) => void;
+        reset: ({ include, exclude, }?: {
+            include?: import("./index.js").FilterName[];
+            exclude?: import("./index.js").FilterName[];
+        }) => void;
+        getAllKeys: () => import("./index.js").FilterName[];
+        getAllValues: () => {
+            [name: import("./index.js").FilterName]: import("./index.js").FilterValue;
+        };
+        getFiltersList: ({ include, exclude, }?: {
+            include?: import("./index.js").FilterName[];
+            exclude?: import("./index.js").FilterName[];
+        }) => import("./index.js").IFilter[];
+    };
+    isRestoring: import("vue").Ref<boolean, boolean>;
+    filtersList: import("vue").ComputedRef<import("./index.js").IFilter[]>;
+    hasFilter: any;
+    addFilter: any;
+    updateFilter: any;
+    deleteFilter: any;
+    setupPersistence: () => Promise<void>;
+}, "hasFilter" | "addFilter" | "updateFilter" | "deleteFilter" | "setupPersistence">>;

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

@@ -0,0 +1,8 @@
+import { Filter, FilterInitParams, FilterInstanceConfig, FilterLabel, FilterName, FilterValue, IFilter } from './classes/Filter';
+import { createFiltersManager, FiltersManagerConfig, IFiltersManager } from './classes/FiltersManager';
+import DynamicFilterSearchComponent from './components/search-bar/dynamic-filter-search.vue';
+import TableFiltersPanelComponent from './components/table-filters-panel.vue';
+import { FilterOption } from './modules/filterConfig/enums/FilterOption';
+export * from './modules/filterConfig';
+export { createFiltersManager, DynamicFilterSearchComponent, Filter, FilterOption, TableFiltersPanelComponent, };
+export type { FilterInitParams, FilterInstanceConfig, FilterLabel, FilterName, FiltersManagerConfig, FilterValue, IFilter, IFiltersManager, };

package/types/modules/filters/modules/filterConfig/classes/FilterConfig.d.ts

@@ -0,0 +1,56 @@
+import { Component } from 'vue';
+import { MessageResolver } from 'vue-i18n';
+import { FilterName, FilterValue } from '../../../classes/Filter';
+export interface BaseFilterConfig {
+    name: FilterName;
+    valueInputComponent: Component;
+    valuePreviewComponent: Component;
+    label?: ReturnType<MessageResolver> | string;
+}
+export type FilterConfigBaseParams = {
+    name?: FilterName;
+    valueInputComponent?: Component;
+    valuePreviewComponent?: Component;
+};
+export interface IWtSysTypeFilterConfig extends BaseFilterConfig {
+    searchRecords: (params: FilterConfigSearchMethodParams) => Promise<{
+        items: unknown[];
+        next?: boolean;
+    }>;
+}
+export type FilterConfigSearchMethodParams = [
+    /**
+     * @description
+     * any request-related data
+     */
+    unknown,
+    /**
+     * @description
+     * filter-related data
+     */
+    {
+        filterName: FilterName;
+        filterValue: FilterValue;
+        filterConfig: BaseFilterConfig;
+    }
+];
+export type TFilterConfig = IWtSysTypeFilterConfig | BaseFilterConfig;
+export declare class FilterConfig implements BaseFilterConfig {
+    name: FilterName;
+    valueInputComponent: Component;
+    valuePreviewComponent: Component;
+    label?: ReturnType<MessageResolver> | string;
+    notDeletable?: boolean;
+    constructor({ name, valueInputComponent, valuePreviewComponent, }?: FilterConfigBaseParams);
+}
+/**
+ * @author @dlohvinov
+ *
+ * @description
+ * "abstract" class is used to support default config fields for all WtSysTypeFilterConfig
+ * classes in future
+ */
+export declare abstract class WtSysTypeFilterConfig extends FilterConfig implements IWtSysTypeFilterConfig {
+    abstract name: any;
+    abstract searchRecords: any;
+}

package/types/modules/filters/modules/filterConfig/classes/createFilterConfig.d.ts

@@ -0,0 +1,2 @@
+import { BaseFilterConfig, FilterConfigBaseParams } from './FilterConfig';
+export declare const createFilterConfig: ({ name, }: Partial<FilterConfigBaseParams> & Pick<FilterConfigBaseParams, "name">) => BaseFilterConfig;

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

@@ -0,0 +1,17 @@
+import { WebitelProtoDataField } from 'webitel-sdk';
+import { FilterConfig } from '../../classes/FilterConfig';
+import { CustomFilterOption } from '../../enums/FilterOption';
+import { BaseFilterConfig, FilterConfigBaseParams } from '../../types/FilterConfig';
+export interface ITypeExtensionFilterConfig extends BaseFilterConfig {
+    readonly field: WebitelProtoDataField;
+}
+declare class TypeExtensionFilterConfig extends FilterConfig implements ITypeExtensionFilterConfig {
+    readonly field: WebitelProtoDataField;
+    constructor({ name }: FilterConfigBaseParams, { field }: {
+        field: WebitelProtoDataField;
+    });
+}
+export declare const createTypeExtensionFilterConfig: (name: CustomFilterOption, { field }: {
+    field: WebitelProtoDataField;
+}) => TypeExtensionFilterConfig;
+export {};

package/types/modules/filters/modules/filterConfig/components/_custom/type-extension-filter-value-field.vue.d.ts

@@ -0,0 +1,15 @@
+import { ITypeExtensionFilterConfig } from "./index";
+type __VLS_Props = {
+    filterConfig: ITypeExtensionFilterConfig;
+};
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue?: unknown;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: unknown) => any;
+    "update:invalid": (args_0: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: unknown) => any;
+    "onUpdate:invalid"?: (args_0: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/types/modules/filters/modules/filterConfig/components/_custom/type-extension-filter-value-preview.vue.d.ts

@@ -0,0 +1,7 @@
+import { DynamicFilterPreviewComponentProps } from '../../types/DynamicFilterPreviewComponent';
+import { ITypeExtensionFilterConfig } from './index';
+type __VLS_Props = DynamicFilterPreviewComponentProps & {
+    filterConfig: ITypeExtensionFilterConfig;
+};
+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;