@webitel/ui-datalist 1.1.49 → 1.1.51

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/ui-datalist",
-	"version": "1.1.49",
+	"version": "1.1.51",
 	"description": "Toolkit for building data lists in webitel ui system",
 	"scripts": {
 		"build:types": "vue-tsc -p ./tsconfig.build.json",
@@ -91,6 +91,10 @@
 		"./card": {
 			"types": "./types/modules/card/index.d.ts",
 			"import": "./src/modules/card/index.ts"
+		},
+		"./permissions-page": {
+			"types": "./types/modules/permissions-page/index.d.ts",
+			"import": "./src/modules/permissions-page/index.ts"
 		}
 	}
 }

package/src/modules/permissions-page/components/permissions-tab.vue

@@ -0,0 +1,79 @@
+<template>
+  <permissions-tab-content v-bind="tabContentProps">
+    <template #pagination>
+      <wt-pagination
+        :next="next"
+        :prev="page > 1"
+        :size="size"
+        debounce
+        @change="updateSize"
+        @next="updatePage(page + 1)"
+        @prev="updatePage(page - 1)"
+      />
+    </template>
+  </permissions-tab-content>
+</template>
+
+<script setup lang="ts">
+import {
+	DEFAULT_PERMISSIONS_USER_ACCESS,
+	PermissionsTabContent,
+	type PermissionsUserAccess,
+} from '@webitel/ui-sdk/modules/ObjectPermissions';
+import type { Id } from '@webitel/ui-sdk/src/api/types/ApiModule';
+import { storeToRefs } from 'pinia';
+import { computed, onUnmounted } from 'vue';
+import type { PermissionsPiniaStore } from '../stores/createPermissionsStore';
+
+const props = withDefaults(
+	defineProps<{
+		store: () => PermissionsPiniaStore;
+		access: PermissionsUserAccess;
+		parentId?: Id;
+	}>(),
+	{
+		access: () => DEFAULT_PERMISSIONS_USER_ACCESS,
+	},
+);
+
+const permissionsStore = props.store();
+
+const { dataList, isLoading, headers, page, size, next, error } =
+	storeToRefs(permissionsStore);
+
+const {
+	initialize,
+	loadDataList,
+	updatePage,
+	updateSize,
+	updateSort,
+	changeAccessMode,
+	addRolePermissions,
+	$reset,
+} = permissionsStore;
+
+initialize({
+	parentId: props.parentId,
+});
+
+onUnmounted(() => {
+	$reset();
+});
+
+const existingGranteeIds = computed(() =>
+	dataList.value.map((item) => item.grantee.id),
+);
+
+const tabContentProps = computed(() => ({
+	dataList: dataList.value,
+	isLoading: isLoading.value,
+	headers: headers.value,
+	error: error.value,
+	refresh: loadDataList,
+	sort: updateSort,
+	changeAccessMode,
+	existingGranteeIds: existingGranteeIds.value,
+	addRolePermissions,
+	access: props.access,
+}));
+</script>

package/src/modules/permissions-page/index.ts

@@ -0,0 +1,23 @@
+import PermissionsTab from './components/permissions-tab.vue';
+
+export {
+	AccessMode,
+	AccessRuleName,
+	headers,
+	PermissionsRolePopup,
+} from '@webitel/ui-sdk/modules/ObjectPermissions';
+
+export { PermissionsApiModule } from './scripts/PermissionsApiModule';
+export type { PermissionsPiniaStore } from './stores/createPermissionsStore';
+export {
+	createPermissionsStore,
+	permissionsStoreBody,
+} from './stores/createPermissionsStore';
+export type {
+	PermissionEntity,
+	PermissionGrantee,
+	PermissionsChange,
+	RawPermissionsApiModule,
+} from './types/Permission.types';
+
+export { PermissionsTab };

package/src/modules/permissions-page/scripts/PermissionsApiModule.ts

@@ -0,0 +1,21 @@
+import type { ApiModule } from '@webitel/ui-sdk/src/api/types/ApiModule';
+
+import type {
+	PermissionEntity,
+	RawPermissionsApiModule,
+} from '../types/Permission.types';
+
+/**
+ * Every card API in api-services/ui-sdk already exposes permissions
+ * via `...generatePermissionsApi(baseUrl)` under `getPermissionsList`/`patchPermissions`.
+ * This adapts that shape to the generic `ApiModule` contract expected by createTableStore,
+ * so no parent API module needs to be rewritten to plug into the permissions store.
+ */
+export const PermissionsApiModule = (
+	rawApiModule: RawPermissionsApiModule,
+): ApiModule<PermissionEntity> => {
+	return {
+		getList: rawApiModule.getPermissionsList,
+		patch: rawApiModule.patchPermissions,
+	} as unknown as ApiModule<PermissionEntity>;
+};

package/src/modules/permissions-page/stores/createPermissionsStore.ts

@@ -0,0 +1,162 @@
+import { AccessMode, headers } from '@webitel/ui-sdk/modules/ObjectPermissions';
+import { AccessRuleName } from '@webitel/ui-sdk/modules/ObjectPermissions/enums';
+import type { Id } from '@webitel/ui-sdk/src/api/types/ApiModule';
+import type { StoreGeneric } from 'pinia';
+import { ref } from 'vue';
+import {
+	createDatalistStore,
+	makeThisToRefs,
+} from '../../_shared/createDatalistStore';
+import { tableStoreBody } from '../../table/createTableStore.store';
+import type { useTableStoreConfig } from '../../types/tableStore.types';
+import { PermissionsApiModule } from '../scripts/PermissionsApiModule';
+import type {
+	ChangeAccessModePayload,
+	PermissionEntity,
+	PermissionsChange,
+	RawPermissionsApiModule,
+} from '../types/Permission.types';
+
+const resolveModeId = (mode: ChangeAccessModePayload['mode']) =>
+	typeof mode === 'number' ? mode : mode?.id;
+
+/*
+ has | patch | got
+-----+-------+-----
+   - |  w    | w
+   w |  w    | -
+   - |  ww   | ww
+   w |  ww   | ww
+  ww |  ww   | w
+  ww |  w    | -
+*/
+const resolveGrants = ({
+	item,
+	ruleName,
+	mode,
+}: ChangeAccessModePayload): string | null => {
+	const have = item.access[ruleName];
+
+	switch (resolveModeId(mode)) {
+		case AccessMode.Forbidden:
+			return ruleName;
+		case AccessMode.Allow:
+			return have.rule || ruleName;
+		case AccessMode.Manage:
+			return `${ruleName}${ruleName}`;
+		default:
+			return null;
+	}
+};
+
+export const permissionsStoreBody = (
+	namespace: string,
+	config: useTableStoreConfig<PermissionEntity>,
+) => {
+	const tableStore = tableStoreBody<PermissionEntity>(namespace, config);
+	const { dataList, selected, error, isLoading } = makeThisToRefs(
+		tableStore,
+		config.storeType,
+	);
+	const {
+		initialize: tableStoreInitialize,
+		loadDataList,
+		resetInfiniteScrollTableParamsToDefaults,
+	} = tableStore;
+
+	/*
+	 * `tableStoreBody` keeps its own `parentId` internally (for `loadDataList`),
+	 * but does not expose it in the `tableStore` API. Permissions patches need
+	 * the same `parentId`, so this store keeps a local copy and syncs it in
+	 * `initialize`.
+	 */
+	const parentId = ref<Id>();
+
+	const initialize: typeof tableStoreInitialize = (options) => {
+		parentId.value = options.parentId;
+		return tableStoreInitialize(options);
+	};
+
+	const patchPermissions = async (changes: PermissionsChange[]) => {
+		try {
+			await (
+				config.apiModule.patch as unknown as (payload: {
+					id: Id;
+					changes: PermissionsChange[];
+				}) => Promise<unknown>
+			)({
+				id: parentId.value,
+				changes,
+			});
+		} finally {
+			await loadDataList();
+		}
+	};
+
+	const changeAccessMode = async (payload: ChangeAccessModePayload) => {
+		const grants = resolveGrants(payload);
+		if (!grants) return;
+
+		return patchPermissions([
+			{
+				grantee: +payload.item.grantee.id,
+				grants,
+			},
+		]);
+	};
+
+	const addRolePermissions = async (role: { id: Id }) => {
+		return patchPermissions([
+			{
+				grantee: +role.id,
+				grants: AccessRuleName.R,
+			},
+		]);
+	};
+	const $reset = () => {
+		dataList.value = [];
+		selected.value = [];
+		error.value = null;
+		isLoading.value = false;
+		resetInfiniteScrollTableParamsToDefaults();
+		parentId.value = null;
+	};
+
+	return {
+		...tableStore,
+
+		parentId,
+		initialize,
+
+		changeAccessMode,
+		addRolePermissions,
+
+		$reset,
+	};
+};
+
+export const createPermissionsStore = (
+	namespace: string,
+	config: Omit<
+		useTableStoreConfig<PermissionEntity>,
+		'apiModule' | 'headers'
+	> & {
+		apiModule: RawPermissionsApiModule;
+		headers?: useTableStoreConfig<PermissionEntity>['headers'];
+	},
+) => {
+	const normalizedConfig: useTableStoreConfig<PermissionEntity> = {
+		...config,
+		apiModule: PermissionsApiModule(config.apiModule),
+		headers: config.headers || headers,
+	};
+
+	return createDatalistStore({
+		storeBody: () => permissionsStoreBody(namespace, normalizedConfig),
+		namespace,
+		config: normalizedConfig,
+	});
+};
+
+export type PermissionsPiniaStore = StoreGeneric &
+	ReturnType<ReturnType<typeof createPermissionsStore>>;

package/src/modules/permissions-page/types/Permission.types.ts

@@ -0,0 +1,47 @@
+import type { AccessRuleName } from '@webitel/ui-sdk/modules/ObjectPermissions/enums';
+import type { ApiModule, Id } from '@webitel/ui-sdk/src/api/types/ApiModule';
+
+export interface PermissionGrantee {
+	id: Id;
+	name?: string;
+	user?: boolean;
+}
+
+export interface PermissionAccessRule {
+	id: number;
+	rule: string;
+}
+
+export interface PermissionEntity {
+	id: string;
+	etag?: string;
+	grantee: PermissionGrantee;
+	access: Record<AccessRuleName, PermissionAccessRule>;
+}
+
+export interface PermissionsChange {
+	grantee: number;
+	grants: string;
+}
+
+/**
+ * Permissions API shape, as produced by generatePermissionsApi (ui-sdk / api-services),
+ * spread into every card API module (e.g. `...generatePermissionsApi(baseUrl)`).
+ */
+export interface RawPermissionsApiModule {
+	getPermissionsList: ApiModule<PermissionEntity>['getList'];
+	patchPermissions: (payload: {
+		id: Id;
+		changes: PermissionsChange[];
+	}) => Promise<unknown>;
+}
+
+export interface ChangeAccessModePayload {
+	item: PermissionEntity;
+	ruleName: AccessRuleName;
+	mode:
+		| {
+				id: number;
+		  }
+		| number;
+}

package/types/modules/permissions-page/components/permissions-tab.vue.d.ts

@@ -0,0 +1,13 @@
+import { type PermissionsUserAccess } from '@webitel/ui-sdk/modules/ObjectPermissions';
+import type { Id } from '@webitel/ui-sdk/src/api/types/ApiModule';
+import type { PermissionsPiniaStore } from '../stores/createPermissionsStore';
+type __VLS_Props = {
+    store: () => PermissionsPiniaStore;
+    access: PermissionsUserAccess;
+    parentId?: Id;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    access: PermissionsUserAccess;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/types/modules/permissions-page/index.d.ts

@@ -0,0 +1,7 @@
+import PermissionsTab from './components/permissions-tab.vue';
+export { AccessMode, AccessRuleName, headers, PermissionsRolePopup, } from '@webitel/ui-sdk/modules/ObjectPermissions';
+export { PermissionsApiModule } from './scripts/PermissionsApiModule';
+export type { PermissionsPiniaStore } from './stores/createPermissionsStore';
+export { createPermissionsStore, permissionsStoreBody, } from './stores/createPermissionsStore';
+export type { PermissionEntity, PermissionGrantee, PermissionsChange, RawPermissionsApiModule, } from './types/Permission.types';
+export { PermissionsTab };

package/types/modules/permissions-page/scripts/PermissionsApiModule.d.ts

@@ -0,0 +1,9 @@
+import type { ApiModule } from '@webitel/ui-sdk/src/api/types/ApiModule';
+import type { PermissionEntity, RawPermissionsApiModule } from '../types/Permission.types';
+/**
+ * Every card API in api-services/ui-sdk already exposes permissions
+ * via `...generatePermissionsApi(baseUrl)` under `getPermissionsList`/`patchPermissions`.
+ * This adapts that shape to the generic `ApiModule` contract expected by createTableStore,
+ * so no parent API module needs to be rewritten to plug into the permissions store.
+ */
+export declare const PermissionsApiModule: (rawApiModule: RawPermissionsApiModule) => ApiModule<PermissionEntity>;

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

@@ -0,0 +1,314 @@
+import type { Id } from '@webitel/ui-sdk/src/api/types/ApiModule';
+import type { StoreGeneric } from 'pinia';
+import type { useTableStoreConfig } from '../../types/tableStore.types';
+import type { ChangeAccessModePayload, PermissionEntity, RawPermissionsApiModule } from '../types/Permission.types';
+export declare const permissionsStoreBody: (namespace: string, config: useTableStoreConfig<PermissionEntity>) => {
+    parentId: import("vue").Ref<Id, Id>;
+    initialize: ({ parentId: storeParentId, }?: {
+        parentId?: string | number;
+    }) => Promise<void>;
+    changeAccessMode: (payload: ChangeAccessModePayload) => Promise<void>;
+    addRolePermissions: (role: {
+        id: Id;
+    }) => Promise<void>;
+    $reset: () => void;
+    isStoreSetUp: import("vue").Ref<boolean, boolean>;
+    dataList: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
+    selected: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
+    error: import("vue").Ref<any, any>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    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];
+        text?: string;
+        width?: string;
+        sort?: boolean;
+        show?: boolean;
+        field: string;
+        shouldBeInitialized?: boolean;
+    }[], import("../../types/tableStore.types").DatalistTableHeader[] | {
+        value: string;
+        locale?: string | [string];
+        text?: string;
+        width?: string;
+        sort?: boolean;
+        show?: boolean;
+        field: string;
+        shouldBeInitialized?: boolean;
+    }[]>;
+    shownHeaders: import("vue").ComputedRef<{
+        value: string;
+        locale?: string | [string];
+        text?: string;
+        width?: string;
+        sort?: boolean;
+        show?: boolean;
+        field: string;
+        shouldBeInitialized?: boolean;
+    }[]>;
+    fields: import("vue").ComputedRef<string[]>;
+    sort: import("vue").ComputedRef<string>;
+    columnWidths: import("vue").ComputedRef<{}>;
+    searchMode: import("vue").Ref<string, string>;
+    filtersManager: import("vue").Ref<{
+        filters: Map<string, {
+            name: import("../../filters").FilterName;
+            value: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+            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;
+        addFilter: (params: import("../../filters").FilterInitParams, payload?: object, config?: import("../../filters").FilterInstanceConfig) => import("../../filters").IFilter;
+        updateFilter: ({ name, }: {
+            name: import("../../filters").FilterName;
+            value?: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+        }) => import("../../filters").IFilter;
+        deleteFilter: ({ name }: {
+            name: import("../../filters").FilterName;
+        }) => import("../../filters").IFilter;
+        toString: (options?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => string;
+        fromString: (snapshotStr: string) => void;
+        reset: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => void;
+        getAllKeys: () => import("../../filters").FilterName[];
+        getAllValues: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => {
+            [name: import("../../filters").FilterName]: import("../../filters").FilterValue;
+        };
+        getFiltersList: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => import("../../filters").IFilter[];
+    }, {
+        filters: Map<string, {
+            name: import("../../filters").FilterName;
+            value: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+            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;
+        addFilter: (params: import("../../filters").FilterInitParams, payload?: object, config?: import("../../filters").FilterInstanceConfig) => import("../../filters").IFilter;
+        updateFilter: ({ name, }: {
+            name: import("../../filters").FilterName;
+            value?: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+        }) => import("../../filters").IFilter;
+        deleteFilter: ({ name }: {
+            name: import("../../filters").FilterName;
+        }) => import("../../filters").IFilter;
+        toString: (options?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => string;
+        fromString: (snapshotStr: string) => void;
+        reset: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => void;
+        getAllKeys: () => import("../../filters").FilterName[];
+        getAllValues: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => {
+            [name: import("../../filters").FilterName]: import("../../filters").FilterValue;
+        };
+        getFiltersList: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => import("../../filters").IFilter[];
+    }>;
+    isFiltersRestoring: import("vue").Ref<boolean, boolean>;
+    setupStore: () => Promise<void>;
+    loadDataList: ({ withLoading, }?: import("../../types/tableStore.types").LoadDataListOptions) => Promise<void>;
+    appendToDataList: () => Promise<void>;
+    updateSelected: (value: PermissionEntity[]) => void;
+    patchItemProperty: ({ index, path, value, }: import("../../types/tableStore.types").PatchItemPropertyParams) => Promise<void>;
+    deleteEls: (_els: PermissionEntity[]) => Promise<void>;
+    resetInfiniteScrollTableParamsToDefaults: () => void;
+    updateSearchMode: (newSearch: string) => void;
+    updatePage: (newPage: number) => void;
+    updateSize: (newSize: number) => void;
+    updateSort: (column: any, options?: {
+        order?: SortSymbols;
+    } | SortSymbols) => void;
+    columnResize: ({ columnName, columnWidth }: {
+        columnName: any;
+        columnWidth: any;
+    }) => void;
+    columnReorder: (orderedFields: string[]) => void;
+    updateShownHeaders: (value: any) => void;
+    hasFilter: any;
+    addFilter: any;
+    updateFilter: any;
+    deleteFilter: any;
+};
+export declare const createPermissionsStore: (namespace: string, config: Omit<useTableStoreConfig<PermissionEntity>, "apiModule" | "headers"> & {
+    apiModule: RawPermissionsApiModule;
+    headers?: useTableStoreConfig<PermissionEntity>["headers"];
+}) => import("../../types/createDatalistStore.types").PatchableStoreFactory<{
+    parentId: import("vue").Ref<Id, Id>;
+    initialize: ({ parentId: storeParentId, }?: {
+        parentId?: string | number;
+    }) => Promise<void>;
+    changeAccessMode: (payload: ChangeAccessModePayload) => Promise<void>;
+    addRolePermissions: (role: {
+        id: Id;
+    }) => Promise<void>;
+    $reset: () => void;
+    isStoreSetUp: import("vue").Ref<boolean, boolean>;
+    dataList: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
+    selected: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
+    error: import("vue").Ref<any, any>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    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];
+        text?: string;
+        width?: string;
+        sort?: boolean;
+        show?: boolean;
+        field: string;
+        shouldBeInitialized?: boolean;
+    }[], import("../../types/tableStore.types").DatalistTableHeader[] | {
+        value: string;
+        locale?: string | [string];
+        text?: string;
+        width?: string;
+        sort?: boolean;
+        show?: boolean;
+        field: string;
+        shouldBeInitialized?: boolean;
+    }[]>;
+    shownHeaders: import("vue").ComputedRef<{
+        value: string;
+        locale?: string | [string];
+        text?: string;
+        width?: string;
+        sort?: boolean;
+        show?: boolean;
+        field: string;
+        shouldBeInitialized?: boolean;
+    }[]>;
+    fields: import("vue").ComputedRef<string[]>;
+    sort: import("vue").ComputedRef<string>;
+    columnWidths: import("vue").ComputedRef<{}>;
+    searchMode: import("vue").Ref<string, string>;
+    filtersManager: import("vue").Ref<{
+        filters: Map<string, {
+            name: import("../../filters").FilterName;
+            value: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+            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;
+        addFilter: (params: import("../../filters").FilterInitParams, payload?: object, config?: import("../../filters").FilterInstanceConfig) => import("../../filters").IFilter;
+        updateFilter: ({ name, }: {
+            name: import("../../filters").FilterName;
+            value?: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+        }) => import("../../filters").IFilter;
+        deleteFilter: ({ name }: {
+            name: import("../../filters").FilterName;
+        }) => import("../../filters").IFilter;
+        toString: (options?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => string;
+        fromString: (snapshotStr: string) => void;
+        reset: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => void;
+        getAllKeys: () => import("../../filters").FilterName[];
+        getAllValues: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => {
+            [name: import("../../filters").FilterName]: import("../../filters").FilterValue;
+        };
+        getFiltersList: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => import("../../filters").IFilter[];
+    }, {
+        filters: Map<string, {
+            name: import("../../filters").FilterName;
+            value: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+            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;
+        addFilter: (params: import("../../filters").FilterInitParams, payload?: object, config?: import("../../filters").FilterInstanceConfig) => import("../../filters").IFilter;
+        updateFilter: ({ name, }: {
+            name: import("../../filters").FilterName;
+            value?: import("../../filters").FilterValue;
+            label?: import("../../filters").FilterLabel;
+        }) => import("../../filters").IFilter;
+        deleteFilter: ({ name }: {
+            name: import("../../filters").FilterName;
+        }) => import("../../filters").IFilter;
+        toString: (options?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => string;
+        fromString: (snapshotStr: string) => void;
+        reset: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => void;
+        getAllKeys: () => import("../../filters").FilterName[];
+        getAllValues: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => {
+            [name: import("../../filters").FilterName]: import("../../filters").FilterValue;
+        };
+        getFiltersList: ({ include, exclude, }?: {
+            include?: import("../../filters").FilterName[];
+            exclude?: import("../../filters").FilterName[];
+        }) => import("../../filters").IFilter[];
+    }>;
+    isFiltersRestoring: import("vue").Ref<boolean, boolean>;
+    setupStore: () => Promise<void>;
+    loadDataList: ({ withLoading, }?: import("../../types/tableStore.types").LoadDataListOptions) => Promise<void>;
+    appendToDataList: () => Promise<void>;
+    updateSelected: (value: PermissionEntity[]) => void;
+    patchItemProperty: ({ index, path, value, }: import("../../types/tableStore.types").PatchItemPropertyParams) => Promise<void>;
+    deleteEls: (_els: PermissionEntity[]) => Promise<void>;
+    resetInfiniteScrollTableParamsToDefaults: () => void;
+    updateSearchMode: (newSearch: string) => void;
+    updatePage: (newPage: number) => void;
+    updateSize: (newSize: number) => void;
+    updateSort: (column: any, options?: {
+        order?: SortSymbols;
+    } | SortSymbols) => void;
+    columnResize: ({ columnName, columnWidth }: {
+        columnName: any;
+        columnWidth: any;
+    }) => void;
+    columnReorder: (orderedFields: string[]) => void;
+    updateShownHeaders: (value: any) => void;
+    hasFilter: any;
+    addFilter: any;
+    updateFilter: any;
+    deleteFilter: any;
+}>;
+export type PermissionsPiniaStore = StoreGeneric & ReturnType<ReturnType<typeof createPermissionsStore>>;

package/types/modules/permissions-page/types/Permission.types.d.ts

@@ -0,0 +1,39 @@
+import type { AccessRuleName } from '@webitel/ui-sdk/modules/ObjectPermissions/enums';
+import type { ApiModule, Id } from '@webitel/ui-sdk/src/api/types/ApiModule';
+export interface PermissionGrantee {
+    id: Id;
+    name?: string;
+    user?: boolean;
+}
+export interface PermissionAccessRule {
+    id: number;
+    rule: string;
+}
+export interface PermissionEntity {
+    id: string;
+    etag?: string;
+    grantee: PermissionGrantee;
+    access: Record<AccessRuleName, PermissionAccessRule>;
+}
+export interface PermissionsChange {
+    grantee: number;
+    grants: string;
+}
+/**
+ * Permissions API shape, as produced by generatePermissionsApi (ui-sdk / api-services),
+ * spread into every card API module (e.g. `...generatePermissionsApi(baseUrl)`).
+ */
+export interface RawPermissionsApiModule {
+    getPermissionsList: ApiModule<PermissionEntity>['getList'];
+    patchPermissions: (payload: {
+        id: Id;
+        changes: PermissionsChange[];
+    }) => Promise<unknown>;
+}
+export interface ChangeAccessModePayload {
+    item: PermissionEntity;
+    ruleName: AccessRuleName;
+    mode: {
+        id: number;
+    } | number;
+}