@flusys/ng-shared 1.1.1-beta → 1.2.0-rc.1

package/types/flusys-ng-shared.d.ts

@@ -1,90 +1,263 @@
-import * as _angular_core from '@angular/core';
-import { Signal, Injector, ResourceRef, model, ElementRef, InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { Signal, PipeTransform, ResourceRef, ResourceStatus, Injector, model, TemplateRef, OnDestroy, ElementRef, DestroyRef, InjectionToken } from '@angular/core';
+import { HttpContextToken, HttpRequest, HttpHandlerFn, HttpEvent, HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
+import * as i3 from '@angular/router';
+import { ResolveFn, CanActivateFn } from '@angular/router';
 import * as i1 from '@angular/common';
 import * as i2 from '@angular/forms';
 import { ControlValueAccessor } from '@angular/forms';
-import * as i3 from '@angular/router';
-import { CanActivateFn } from '@angular/router';
-import * as i1$1 from 'primeng/autocomplete';
-import * as i2$1 from 'primeng/avatar';
-import * as i3$1 from 'primeng/button';
-import * as i4 from 'primeng/card';
-import * as i5 from 'primeng/checkbox';
-import { CheckboxChangeEvent } from 'primeng/checkbox';
-import * as i6 from 'primeng/confirmdialog';
-import * as i7 from 'primeng/datepicker';
-import * as i8 from 'primeng/dialog';
-import * as i9 from 'primeng/divider';
-import * as i10 from 'primeng/fileupload';
-import * as i11 from 'primeng/iconfield';
-import * as i12 from 'primeng/image';
-import * as i13 from 'primeng/inputicon';
-import * as i14 from 'primeng/inputnumber';
-import * as i15 from 'primeng/inputtext';
-import * as i16 from 'primeng/listbox';
-import * as i17 from 'primeng/multiselect';
-import * as i18 from 'primeng/paginator';
-import * as i19 from 'primeng/panel';
-import * as i20 from 'primeng/password';
-import * as i21 from 'primeng/popover';
-import * as i22 from 'primeng/progressbar';
-import * as i23 from 'primeng/radiobutton';
-import * as i24 from 'primeng/ripple';
-import * as i25 from 'primeng/selectbutton';
-import * as i26 from 'primeng/select';
-import * as i27 from 'primeng/skeleton';
-import * as i28 from 'primeng/splitbutton';
-import * as i29 from 'primeng/steps';
-import * as i30 from 'primeng/table';
-import * as i31 from 'primeng/tabs';
-import * as i32 from 'primeng/tag';
-import * as i33 from 'primeng/textarea';
-import * as i34 from 'primeng/toast';
-import * as i35 from 'primeng/toggleswitch';
-import * as i36 from 'primeng/tooltip';
-import * as i37 from 'primeng/treetable';
 import * as _flusys_ng_shared from '@flusys/ng-shared';
-import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
-import { ApiLoaderService } from '@flusys/ng-core';
+import { ServiceName } from '@flusys/ng-core';
 import { FormValueControl } from '@angular/forms/signals';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { CheckboxChangeEvent } from '@flusys/ng-ui';
 
-/**
- * Auth State Provider Interface
- *
- * Abstracts auth state access for feature packages (form-builder, etc.)
- * that need to check authentication status without depending on ng-auth directly.
- *
- * @example
- * // In form-builder component
- * class PublicFormPageComponent {
- *   private readonly authStateProvider = inject(AUTH_STATE_PROVIDER);
- *
- *   ngOnInit() {
- *     this.authStateProvider.initialize().subscribe({
- *       next: () => this.checkFormAccess(),
- *       error: () => this.checkFormAccess(),
- *     });
- *   }
- *
- *   checkAccess() {
- *     if (this.authStateProvider.isAuthenticated()) {
- *       // User is logged in
- *     }
- *   }
- * }
- */
-interface IAuthStateProvider {
-    /**
-     * Signal indicating if user is currently authenticated
-     */
-    isAuthenticated: Signal<boolean>;
-    /**
-     * Initialize auth state (restore session from cookies/storage)
-     * Call this before checking isAuthenticated for users returning after login
-     */
-    initialize(): Observable<void>;
-}
+declare const SHARED_MESSAGES: Record<string, string>;
+
+declare const USER_PERMISSIONS: {
+    readonly CREATE: "user.create";
+    readonly READ: "user.read";
+    readonly UPDATE: "user.update";
+    readonly DELETE: "user.delete";
+};
+declare const COMPANY_PERMISSIONS: {
+    readonly CREATE: "company.create";
+    readonly READ: "company.read";
+    readonly UPDATE: "company.update";
+    readonly DELETE: "company.delete";
+};
+declare const BRANCH_PERMISSIONS: {
+    readonly CREATE: "branch.create";
+    readonly READ: "branch.read";
+    readonly UPDATE: "branch.update";
+    readonly DELETE: "branch.delete";
+};
+declare const ACTION_PERMISSIONS: {
+    readonly CREATE: "action.create";
+    readonly READ: "action.read";
+    readonly UPDATE: "action.update";
+    readonly DELETE: "action.delete";
+};
+declare const ROLE_PERMISSIONS: {
+    readonly CREATE: "role.create";
+    readonly READ: "role.read";
+    readonly UPDATE: "role.update";
+    readonly DELETE: "role.delete";
+};
+declare const ROLE_ACTION_PERMISSIONS: {
+    readonly READ: "role-action.read";
+    readonly ASSIGN: "role-action.assign";
+};
+declare const USER_ROLE_PERMISSIONS: {
+    readonly READ: "user-role.read";
+    readonly ASSIGN: "user-role.assign";
+};
+declare const USER_ACTION_PERMISSIONS: {
+    readonly READ: "user-action.read";
+    readonly ASSIGN: "user-action.assign";
+};
+declare const COMPANY_ACTION_PERMISSIONS: {
+    readonly READ: "company-action.read";
+    readonly ASSIGN: "company-action.assign";
+};
+declare const FILE_PERMISSIONS: {
+    readonly CREATE: "file.create";
+    readonly READ: "file.read";
+    readonly UPDATE: "file.update";
+    readonly DELETE: "file.delete";
+};
+declare const FOLDER_PERMISSIONS: {
+    readonly CREATE: "folder.create";
+    readonly READ: "folder.read";
+    readonly UPDATE: "folder.update";
+    readonly DELETE: "folder.delete";
+};
+declare const STORAGE_CONFIG_PERMISSIONS: {
+    readonly CREATE: "storage-config.create";
+    readonly READ: "storage-config.read";
+    readonly UPDATE: "storage-config.update";
+    readonly DELETE: "storage-config.delete";
+};
+declare const UPLOAD_CONFIG_PERMISSIONS: {
+    readonly DELETE: "upload-config.delete";
+};
+declare const EMAIL_CONFIG_PERMISSIONS: {
+    readonly CREATE: "email-config.create";
+    readonly READ: "email-config.read";
+    readonly UPDATE: "email-config.update";
+    readonly DELETE: "email-config.delete";
+};
+declare const EMAIL_TEMPLATE_PERMISSIONS: {
+    readonly CREATE: "email-template.create";
+    readonly READ: "email-template.read";
+    readonly UPDATE: "email-template.update";
+    readonly DELETE: "email-template.delete";
+};
+declare const FORM_PERMISSIONS: {
+    readonly CREATE: "form.create";
+    readonly READ: "form.read";
+    readonly UPDATE: "form.update";
+    readonly DELETE: "form.delete";
+};
+declare const FORM_RESULT_PERMISSIONS: {
+    readonly CREATE: "form-result.create";
+    readonly READ: "form-result.read";
+    readonly UPDATE: "form-result.update";
+    readonly DELETE: "form-result.delete";
+};
+declare const EVENT_PERMISSIONS: {
+    readonly CREATE: "event.create";
+    readonly READ: "event.read";
+    readonly UPDATE: "event.update";
+    readonly DELETE: "event.delete";
+};
+declare const NOTIFICATION_PERMISSIONS: {
+    readonly CREATE: "notification.create";
+    readonly READ: "notification.read";
+    readonly UPDATE: "notification.update";
+    readonly DELETE: "notification.delete";
+};
+declare const LANGUAGE_PERMISSIONS: {
+    readonly CREATE: "language.create";
+    readonly READ: "language.read";
+    readonly UPDATE: "language.update";
+    readonly DELETE: "language.delete";
+};
+declare const TRANSLATION_KEY_PERMISSIONS: {
+    readonly CREATE: "translation-key.create";
+    readonly READ: "translation-key.read";
+    readonly UPDATE: "translation-key.update";
+    readonly DELETE: "translation-key.delete";
+};
+declare const TRANSLATION_PERMISSIONS: {
+    readonly CREATE: "translation.create";
+    readonly READ: "translation.read";
+    readonly UPDATE: "translation.update";
+    readonly DELETE: "translation.delete";
+};
+declare const PERMISSIONS: {
+    readonly USER: {
+        readonly CREATE: "user.create";
+        readonly READ: "user.read";
+        readonly UPDATE: "user.update";
+        readonly DELETE: "user.delete";
+    };
+    readonly COMPANY: {
+        readonly CREATE: "company.create";
+        readonly READ: "company.read";
+        readonly UPDATE: "company.update";
+        readonly DELETE: "company.delete";
+    };
+    readonly BRANCH: {
+        readonly CREATE: "branch.create";
+        readonly READ: "branch.read";
+        readonly UPDATE: "branch.update";
+        readonly DELETE: "branch.delete";
+    };
+    readonly ACTION: {
+        readonly CREATE: "action.create";
+        readonly READ: "action.read";
+        readonly UPDATE: "action.update";
+        readonly DELETE: "action.delete";
+    };
+    readonly ROLE: {
+        readonly CREATE: "role.create";
+        readonly READ: "role.read";
+        readonly UPDATE: "role.update";
+        readonly DELETE: "role.delete";
+    };
+    readonly ROLE_ACTION: {
+        readonly READ: "role-action.read";
+        readonly ASSIGN: "role-action.assign";
+    };
+    readonly USER_ROLE: {
+        readonly READ: "user-role.read";
+        readonly ASSIGN: "user-role.assign";
+    };
+    readonly USER_ACTION: {
+        readonly READ: "user-action.read";
+        readonly ASSIGN: "user-action.assign";
+    };
+    readonly COMPANY_ACTION: {
+        readonly READ: "company-action.read";
+        readonly ASSIGN: "company-action.assign";
+    };
+    readonly FILE: {
+        readonly CREATE: "file.create";
+        readonly READ: "file.read";
+        readonly UPDATE: "file.update";
+        readonly DELETE: "file.delete";
+    };
+    readonly FOLDER: {
+        readonly CREATE: "folder.create";
+        readonly READ: "folder.read";
+        readonly UPDATE: "folder.update";
+        readonly DELETE: "folder.delete";
+    };
+    readonly STORAGE_CONFIG: {
+        readonly CREATE: "storage-config.create";
+        readonly READ: "storage-config.read";
+        readonly UPDATE: "storage-config.update";
+        readonly DELETE: "storage-config.delete";
+    };
+    readonly EMAIL_CONFIG: {
+        readonly CREATE: "email-config.create";
+        readonly READ: "email-config.read";
+        readonly UPDATE: "email-config.update";
+        readonly DELETE: "email-config.delete";
+    };
+    readonly EMAIL_TEMPLATE: {
+        readonly CREATE: "email-template.create";
+        readonly READ: "email-template.read";
+        readonly UPDATE: "email-template.update";
+        readonly DELETE: "email-template.delete";
+    };
+    readonly FORM: {
+        readonly CREATE: "form.create";
+        readonly READ: "form.read";
+        readonly UPDATE: "form.update";
+        readonly DELETE: "form.delete";
+    };
+    readonly FORM_RESULT: {
+        readonly CREATE: "form-result.create";
+        readonly READ: "form-result.read";
+        readonly UPDATE: "form-result.update";
+        readonly DELETE: "form-result.delete";
+    };
+    readonly EVENT: {
+        readonly CREATE: "event.create";
+        readonly READ: "event.read";
+        readonly UPDATE: "event.update";
+        readonly DELETE: "event.delete";
+    };
+    readonly NOTIFICATION: {
+        readonly CREATE: "notification.create";
+        readonly READ: "notification.read";
+        readonly UPDATE: "notification.update";
+        readonly DELETE: "notification.delete";
+    };
+    readonly LANGUAGE: {
+        readonly CREATE: "language.create";
+        readonly READ: "language.read";
+        readonly UPDATE: "language.update";
+        readonly DELETE: "language.delete";
+    };
+    readonly TRANSLATION_KEY: {
+        readonly CREATE: "translation-key.create";
+        readonly READ: "translation-key.read";
+        readonly UPDATE: "translation-key.update";
+        readonly DELETE: "translation-key.delete";
+    };
+    readonly TRANSLATION: {
+        readonly CREATE: "translation.create";
+        readonly READ: "translation.read";
+        readonly UPDATE: "translation.update";
+        readonly DELETE: "translation.delete";
+    };
+};
+type PermissionCode = (typeof PERMISSIONS)[keyof typeof PERMISSIONS][keyof (typeof PERMISSIONS)[keyof typeof PERMISSIONS]];
 
 /**
  * Base entity interface - matches backend Identity entity
@@ -123,12 +296,6 @@ interface IActivatable {
 interface IOrderable {
     serial?: number | null;
 }
-/**
- * Entity with metadata JSON field
- */
-interface IMetadata {
-    metadata?: Record<string, unknown> | null;
-}
 /**
  * Logged-in user info - matches backend ILoggedUserInfo
  */
@@ -143,6 +310,42 @@ interface ILoggedUserInfo {
     companyLogoId?: string;
     branchLogoId?: string;
 }
+/**
+ * Simple dropdown item for select components
+ */
+interface IDropDown {
+    label: string;
+    value: string;
+}
+/**
+ * Delete operation types
+ * - 'delete': Soft delete (sets deletedAt timestamp)
+ * - 'restore': Restore soft-deleted item (clears deletedAt)
+ * - 'permanent': Permanently delete from database
+ */
+type DeleteType = 'delete' | 'restore' | 'permanent';
+/**
+ * Delete request payload - matches backend DeleteDto
+ */
+interface IDeleteData {
+    /** Single ID or array of IDs to delete */
+    id: string | string[];
+    /** Type of delete operation */
+    type: DeleteType;
+}
+/** Action node - checks a single permission */
+interface IActionNode {
+    type: 'action';
+    actionId: string;
+}
+/** Group node - combines children with AND/OR logic */
+interface IGroupNode {
+    type: 'group';
+    operator: 'AND' | 'OR';
+    children: ILogicNode[];
+}
+/** Permission logic tree (discriminated union of action/group) */
+type ILogicNode = IActionNode | IGroupNode;
 
 /**
  * Request metadata added by backend ResponseMetaInterceptor
@@ -171,20 +374,14 @@ interface IBulkMeta {
     failed?: number;
     total?: number;
 }
-/**
- * Validation error detail
- */
-interface IValidationError {
-    field: string;
-    message: string;
-    constraint?: string;
-}
 /**
  * Single item response (insert, update, get-by-id)
  */
 interface ISingleResponse<T> {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, unknown>;
     data?: T;
     _meta?: IRequestMeta;
 }
@@ -194,6 +391,8 @@ interface ISingleResponse<T> {
 interface IListResponse<T> {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, unknown>;
     data?: T[];
     meta: IPaginationMeta;
     _meta?: IRequestMeta;
@@ -204,6 +403,8 @@ interface IListResponse<T> {
 interface IBulkResponse<T> {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, unknown>;
     data?: T[];
     meta: IBulkMeta;
     _meta?: IRequestMeta;
@@ -214,128 +415,74 @@ interface IBulkResponse<T> {
 interface IMessageResponse {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, unknown>;
     _meta?: IRequestMeta;
 }
-/**
- * Error response
- */
-interface IErrorResponse {
-    success: false;
-    message: string;
-    code?: string;
-    errors?: IValidationError[];
-    _meta?: IRequestMeta;
-}
-/**
- * Union type for all API responses
- */
-type ApiResponse<T> = ISingleResponse<T> | IListResponse<T> | IBulkResponse<T> | IMessageResponse | IErrorResponse;
-interface IUserCompanyPayload {
+
+interface IFileBasicInfo {
     id: string;
     name: string;
-    slug: string;
-    logoId?: string;
+    contentType: string;
+    size: string;
+    url: string | null;
 }
-interface IUserBranchPayload {
-    id: string;
+interface IUploadedFile {
+    id?: string;
     name: string;
-    slug: string;
-    logoId?: string;
+    key: string;
+    size: number;
+    contentType: string;
 }
-interface ILoginUserData {
+interface IFolderBasicInfo {
     id: string;
     name: string;
-    email: string;
-    phone?: string;
-    profilePictureId?: string | null;
-    companyId?: string;
-    branchId?: string;
-    company?: IUserCompanyPayload;
-    branch?: IUserBranchPayload;
-}
-interface ILoginResponse {
-    success: boolean;
-    message: string;
-    data: {
-        accessToken: string;
-        refreshToken: string;
-        user: ILoginUserData;
-    };
-    _meta?: IRequestMeta;
-}
-interface IRefreshTokenResponse {
-    success: boolean;
-    message: string;
-    data: {
-        accessToken: string;
-        refreshToken?: string;
-    };
-    _meta?: IRequestMeta;
+    slug: string;
 }
-interface IFileData {
+interface IStorageConfigBasicInfo {
     id: string;
     name: string;
-    originalName: string;
-    contentType: string;
-    size: number;
-    key: string;
-    url?: string;
-    thumbnailUrl?: string;
-    createdAt: Date;
+    isDefault: boolean;
 }
-
-/**
- * Company basic info for dropdowns
- */
-interface ICompanyBasicInfo {
-    id: string;
-    name: string;
-    slug?: string;
-}
-interface ICompanyApiProvider {
-    /**
-     * Get list of companies with pagination
-     */
-    getCompanies(filter?: {
-        page?: number;
-        pageSize?: number;
-        search?: string;
-        [key: string]: any;
-    }): Observable<IListResponse<ICompanyBasicInfo>>;
+interface IFileUploadOptions {
+    storageConfigId?: string;
+    folderPath?: string;
+    maxWidth?: number;
+    maxHeight?: number;
+    quality?: number;
+    compress?: boolean;
+    isPrivate?: boolean;
 }
-
-/**
- * Delete operation types
- * - 'delete': Soft delete (sets deletedAt timestamp)
- * - 'restore': Restore soft-deleted item (clears deletedAt)
- * - 'permanent': Permanently delete from database
- */
-type DeleteType = 'delete' | 'restore' | 'permanent';
-/**
- * Delete request payload - matches backend DeleteDto
- */
-interface IDeleteData {
-    /** Single ID or array of IDs to delete */
-    id: string | string[];
-    /** Type of delete operation */
-    type: DeleteType;
+interface ISelectFilter {
+    page: number;
+    pageSize: number;
+    search: string;
 }
-
-interface IDropDown {
-    label: string;
-    value: string;
+interface IFileSelectFilter extends ISelectFilter {
+    contentTypes?: string[];
+    folderId?: string;
+    storageConfigId?: string;
 }
+type UploadFileFn = (file: File, options?: IFileUploadOptions) => Observable<ISingleResponse<IUploadedFile>>;
+type UploadMultipleFilesFn = (files: File[], options?: IFileUploadOptions) => Observable<ISingleResponse<IUploadedFile[]>>;
+declare const FILE_TYPE_FILTERS: {
+    readonly IMAGES: readonly ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"];
+    readonly DOCUMENTS: readonly ["application/pdf", "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"];
+    readonly VIDEOS: readonly ["video/mp4", "video/webm", "video/ogg", "video/quicktime"];
+    readonly AUDIO: readonly ["audio/mpeg", "audio/wav", "audio/ogg", "audio/webm"];
+    readonly ALL: string[];
+};
+declare function getAcceptString(contentTypes: string[]): string;
+declare function isFileTypeAllowed(file: File, allowedTypes: string[]): boolean;
+declare function getFileIconClass(contentType: string): string;
+declare function formatFileSize(sizeInKb: string | number): string;
 
 interface IPagination {
     pageSize: number;
     currentPage: number;
 }
-interface ISort {
-    [key: string]: 'ASC' | 'DESC';
-}
-interface IFilter {
-    [key: string]: any;
-}
+type ISort = Record<string, 'ASC' | 'DESC'>;
+type IFilter = Record<string, string | number | boolean | null | undefined | string[] | number[]>;
 interface IFilterData {
     filter?: IFilter;
     pagination?: IPagination;
@@ -345,46 +492,18 @@ interface IFilterData {
     extraKey?: string[];
 }
 
-/** Action node - checks a single permission */
-interface IActionNode {
-    type: 'action';
-    actionId: string;
-}
-/** Group node - combines children with AND/OR logic */
-interface IGroupNode {
-    type: 'group';
-    operator: 'AND' | 'OR';
-    children: ILogicNode[];
-}
-/** Permission logic tree (discriminated union of action/group) */
-type ILogicNode = IActionNode | IGroupNode;
-
 /**
- * User Permission Provider Interface
- *
- * Abstracts user permission data access operations.
- * Implemented by auth package, used by IAM for user permission queries.
- *
- * @example
- * // In IAM component
- * class UserActionSelectorComponent {
- *   private readonly userPermissionProvider = inject(USER_PERMISSION_PROVIDER);
+ * Auth State Provider Interface
  *
- *   async loadUserBranches(userId: string) {
- *     const response = await this.userPermissionProvider
- *       .getUserBranchPermissions(userId, '')
- *       .toPromise();
- *     this.branches.set(response?.data ?? []);
- *   }
- * }
+ * Abstracts auth state access for feature packages (form-builder, etc.)
+ * that need to check authentication status without depending on ng-auth directly.
  */
-interface IUserPermissionProvider {
-    /**
-     * Get user's branch permissions
-     */
-    getUserBranchPermissions(userId: string): Observable<ISingleResponse<any>>;
+interface IAuthStateProvider {
+    /** Signal indicating if user is currently authenticated */
+    isAuthenticated: Signal<boolean>;
+    /** Initialize auth state (restore session from cookies/storage) */
+    initialize(): Observable<void>;
 }
-
 /**
  * User data for dropdowns and selectors
  */
@@ -394,381 +513,103 @@ interface IUserBasicInfo {
     email: string;
 }
 /**
- * User Provider Interface
- *
- * Abstracts user data access for IAM and other feature packages.
- * Implemented by auth package, used by IAM for user selection in permission assignment.
- *
- * @example
- * // In IAM component
- * class UserActionSelectorComponent {
- *   private readonly userProvider = inject(USER_PROVIDER);
- *
- *   loadUsers() {
- *     this.userProvider.getUsers({ page: 0, pageSize: 50 }).subscribe(users => {
- *       this.users.set(users.data);
- *     });
- *   }
- * }
+ * User Provider Interface - Abstracts user data access for IAM and other feature packages.
  */
 interface IUserProvider {
-    /**
-     * Get list of users with pagination
-     * @param filter Optional filter (page, pageSize, search, etc.)
-     */
     getUsers(filter?: {
         page?: number;
         pageSize?: number;
         search?: string;
-        companyId?: string;
-        branchId?: string;
-        [key: string]: any;
+        isActive?: boolean;
+        [key: string]: unknown;
     }): Observable<IListResponse<IUserBasicInfo>>;
 }
-
 /** Filter params passed to loadUsers function */
 interface IUserSelectFilter {
     page: number;
     pageSize: number;
     search: string;
-    [key: string]: unknown;
 }
 /** Function type for loading users */
 type LoadUsersFn = (filter: IUserSelectFilter) => Observable<IListResponse<IUserBasicInfo>>;
-
 /**
- * Basic file info for selectors and displays
+ * User branch permission data
  */
-interface IFileBasicInfo {
-    id: string;
-    name: string;
-    contentType: string;
-    size: string;
-    url: string | null;
+interface IUserBranchPermission {
+    branchId: string;
+    branchName: string;
+    companyId: string;
 }
 /**
- * Upload options for file uploader
+ * User Permission Provider Interface - Abstracts user permission data access operations.
  */
-interface IFileUploadOptions {
-    storageConfigId?: string;
-    folderPath?: string;
-    maxWidth?: number;
-    maxHeight?: number;
-    quality?: number;
-    compress?: boolean;
+interface IUserPermissionProvider {
+    getUserBranchPermissions(userId: string): Observable<ISingleResponse<IUserBranchPermission[]>>;
 }
 /**
- * Uploaded file response
+ * Company basic info for dropdowns
  */
-interface IUploadedFile {
-    id?: string;
+interface ICompanyBasicInfo {
+    id: string;
     name: string;
-    key: string;
-    size: number;
-    contentType: string;
+    slug?: string;
 }
 /**
- * Filter params for file selector
+ * Company API Provider Interface
  */
-interface IFileSelectFilter {
-    page: number;
-    pageSize: number;
-    search: string;
-    contentTypes?: string[];
-    folderId?: string;
-    [key: string]: unknown;
+interface ICompanyApiProvider {
+    getCompanies(filter?: {
+        page?: number;
+        pageSize?: number;
+        search?: string;
+    }): Observable<IListResponse<ICompanyBasicInfo>>;
 }
-/**
- * Function type for loading files
- */
-type LoadFilesFn = (filter: IFileSelectFilter) => Observable<IListResponse<IFileBasicInfo>>;
-/**
- * Function type for uploading a file
- */
-type UploadFileFn = (file: File, options?: IFileUploadOptions) => Observable<ISingleResponse<IUploadedFile>>;
-/**
- * Function type for getting file URLs (presigned URL refresh)
- */
-type GetFileUrlsFn = (fileIds: string[]) => Observable<ISingleResponse<IFileBasicInfo[]>>;
-/**
- * Common file type filters
- */
-declare const FILE_TYPE_FILTERS: {
-    readonly IMAGES: readonly ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"];
-    readonly DOCUMENTS: readonly ["application/pdf", "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"];
-    readonly VIDEOS: readonly ["video/mp4", "video/webm", "video/ogg", "video/quicktime"];
-    readonly AUDIO: readonly ["audio/mpeg", "audio/wav", "audio/ogg", "audio/webm"];
-    readonly ALL: string[];
-};
-/**
- * Get accept string for file input from content types
- */
-declare function getAcceptString(contentTypes: string[]): string;
-/**
- * Check if file matches allowed content types
- */
-declare function isFileTypeAllowed(file: File, allowedTypes: string[]): boolean;
-/**
- * Get file icon class based on content type
- */
-declare function getFileIconClass(contentType: string): string;
-/**
- * Format file size for display
- */
-declare function formatFileSize(sizeInKb: string | number): string;
-
 /**
  * User role info for profile display
  */
 interface IProfileRoleInfo {
     id: string;
     name: string;
-    description?: string | null;
-}
-/**
- * User action info for profile display
- */
-interface IProfileActionInfo {
-    id: string;
-    name: string;
-    code: string;
-    description?: string | null;
-}
-/**
- * Profile Permission Provider Interface
- *
- * Abstracts permission data access for profile page.
- * Implemented by ng-iam, consumed by ng-auth profile page.
- * Optional injection - if not provided, permissions section is hidden.
- *
- * @example
- * // In profile component
- * private readonly permissionProvider = inject(PROFILE_PERMISSION_PROVIDER, { optional: true });
- *
- * ngOnInit() {
- *   if (this.permissionProvider) {
- *     this.loadPermissions();
- *   }
- * }
- */
-interface IProfilePermissionProvider {
-    /**
-     * Get user's assigned roles
-     * @param userId User ID
-     * @param branchId Optional branch ID for branch-scoped roles
-     */
-    getUserRoles(userId: string, branchId?: string): Observable<ISingleResponse<IProfileRoleInfo[]>>;
-    /**
-     * Get user's direct actions
-     * @param userId User ID
-     * @param branchId Optional branch ID for branch-scoped actions
-     */
-    getUserActions(userId: string, branchId?: string): Observable<ISingleResponse<IProfileActionInfo[]>>;
-}
-
-/**
- * Uploaded file result with file manager ID
- */
-interface IProfileUploadResult {
-    /** File manager ID (UUID) for storing in profilePictureId */
-    id: string;
-    /** Original file name */
-    name: string;
-    /** Storage key/path */
-    key: string;
-    /** File size in bytes */
-    size: number;
-    /** MIME type */
-    contentType: string;
-}
-/**
- * Profile Upload Options
- */
-interface IProfileUploadOptions {
-    /** Folder path for organizing uploads */
-    folderPath?: string;
-    /** Enable image compression */
-    compress?: boolean;
-    /** Max width for image compression */
-    maxWidth?: number;
-    /** Max height for image compression */
-    maxHeight?: number;
-}
-/**
- * Profile Upload Provider Interface
- *
- * Provides file upload functionality for profile pictures.
- * Implemented by ng-storage, consumed by ng-auth profile page.
- *
- * This interface enables ng-auth to use storage functionality
- * without directly depending on ng-storage package.
- */
-interface IProfileUploadProvider {
-    /**
-     * Upload profile picture and register in file manager
-     * Returns file manager ID (UUID) for storing in user.profilePictureId
-     *
-     * @param file - File to upload
-     * @param options - Upload options (compression, folder, etc.)
-     * @returns Observable with upload result including file manager ID
-     */
-    uploadProfilePicture(file: File, options?: IProfileUploadOptions): Observable<ISingleResponse<IProfileUploadResult>>;
-}
-
-/**
- * Base user interface for list operations
- * Extends this with app-specific user fields
- */
-interface IUserListItem {
-    id: string;
-    name: string;
-    email: string;
-    phone?: string;
-    isActive?: boolean;
-    [key: string]: unknown;
-}
-/**
- * User list action definition
- * @template T User type, defaults to IUserListItem
- */
-interface IUserListAction<T = IUserListItem> {
-    /** Unique action identifier */
-    id: string;
-    /** Display label */
-    label: string;
-    /** PrimeNG icon class (e.g., 'pi pi-pencil') */
-    icon?: string;
-    /** Severity for styling (e.g., 'primary', 'danger', 'warning') */
-    severity?: 'primary' | 'secondary' | 'success' | 'info' | 'warn' | 'danger' | 'help' | 'contrast';
-    /** Permission code required (checked via hasPermission) */
-    permission?: string;
-    /** Tooltip text */
-    tooltip?: string;
-    /** Whether action is disabled */
-    disabled?: boolean | ((user: T) => boolean);
-    /** Whether action is visible */
-    visible?: boolean | ((user: T) => boolean);
-}
-/**
- * Extra column definition for user list
- */
-interface IUserListColumn {
-    /** Column field name */
-    field: string;
-    /** Column header label */
-    header: string;
-    /** Column width */
-    width?: string;
-    /** Whether column is sortable */
-    sortable?: boolean;
-    /** Whether column is filterable */
-    filterable?: boolean;
-    /** Custom template type for rendering */
-    templateType?: 'text' | 'badge' | 'date' | 'boolean' | 'custom';
-}
-/**
- * User List Provider Interface
- *
- * Allows consuming applications to extend user list pages with:
- * - Extra columns
- * - Extra row actions
- * - Extra toolbar actions
- * - Custom data enrichment
- *
- * This follows the Provider Interface Pattern:
- * - ng-shared defines the interface (this file)
- * - Consuming apps (via ng-iam or app-specific) implement the interface
- * - ng-auth user list optionally injects and uses the implementation
- *
- * @template T User type, defaults to IUserListItem
- *
- * @example
- * // In app.config.ts
- * providers: [
- *   { provide: USER_LIST_PROVIDER, useClass: MyUserListProvider },
- * ]
- *
- * // Implementation
- * @Injectable({ providedIn: 'root' })
- * export class MyUserListProvider implements IUserListProvider {
- *   getExtraRowActions() {
- *     return [
- *       { id: 'assign-role', label: 'Assign Role', icon: 'pi pi-users' },
- *     ];
- *   }
- * }
- */
-interface IUserListProvider<T extends IUserListItem = IUserListItem> {
-    /**
-     * Get extra columns to display in user list
-     * @returns Array of extra column definitions
-     */
-    getExtraColumns?(): IUserListColumn[];
-    /**
-     * Get extra row-level actions (per-user actions)
-     * Displayed in actions column for each row
-     * @returns Array of action definitions
-     */
-    getExtraRowActions?(): IUserListAction<T>[];
-    /**
-     * Get extra toolbar actions
-     * Displayed in toolbar above the list
-     * @returns Array of action definitions
-     */
-    getExtraToolbarActions?(): IUserListAction<T>[];
-    /**
-     * Handle row action click
-     * @param actionId Action identifier
-     * @param user User data from the row
-     */
-    onRowAction?(actionId: string, user: T): void;
-    /**
-     * Handle toolbar action click
-     * @param actionId Action identifier
-     * @param selectedUsers Currently selected users (for bulk actions)
-     */
-    onToolbarAction?(actionId: string, selectedUsers: T[]): void;
-    /**
-     * Enrich user list data with extra fields
-     * Called after data is loaded from API
-     * @param users List of users from API
-     * @returns Observable of enriched users
-     */
-    enrichListData?(users: T[]): Observable<T[]>;
-    /**
-     * Get extra filters for user list
-     * @returns Array of filter definitions
-     */
-    getExtraFilters?(): IUserListFilter[];
+    description?: string | null;
 }
 /**
- * Extra filter definition for user list
+ * User action info for profile display
  */
-interface IUserListFilter {
-    /** Filter field name */
-    field: string;
-    /** Filter label */
-    label: string;
-    /** Filter type */
-    type: 'text' | 'dropdown' | 'multiselect' | 'date' | 'boolean';
-    /** Options for dropdown/multiselect */
-    options?: {
-        label: string;
-        value: string | number | boolean;
-    }[];
-    /** Placeholder text */
-    placeholder?: string;
+interface IProfileActionInfo {
+    id: string;
+    name: string;
+    code: string;
+    description?: string | null;
 }
-
-declare enum ContactTypeEnum {
-    PHONE = 1,
-    EMAIL = 2
+/**
+ * Profile Permission Provider Interface - Abstracts permission data access for profile page.
+ */
+interface IProfilePermissionProvider {
+    getUserRoles(userId: string, branchId?: string): Observable<ISingleResponse<IProfileRoleInfo[]>>;
+    getUserActions(userId: string, branchId?: string): Observable<ISingleResponse<IProfileActionInfo[]>>;
+}
+/**
+ * File Provider Interface - Provides file loading and upload functionality.
+ * Used by FileSelectorDialogComponent to load files and handle uploads.
+ */
+interface IFileProvider {
+    /** Load files with filtering and pagination */
+    loadFiles(filter: IFileSelectFilter): Observable<IListResponse<IFileBasicInfo>>;
+    /** Upload a single file and register in file manager */
+    uploadFile(file: File, options?: IFileUploadOptions): Observable<ISingleResponse<IUploadedFile>>;
+    /** Upload multiple files at once (more efficient batch upload) */
+    uploadMultipleFiles?(files: File[], options?: IFileUploadOptions): Observable<ISingleResponse<IUploadedFile[]>>;
+    /** Get file URLs by IDs (for refreshing presigned URLs) */
+    getFileUrls?(fileIds: string[]): Observable<ISingleResponse<IFileBasicInfo[]>>;
+    /** Load folders for folder selector (optional) */
+    loadFolders?(filter: ISelectFilter): Observable<IListResponse<IFolderBasicInfo>>;
+    /** Load storage configs for config selector (optional) */
+    loadStorageConfigs?(filter: ISelectFilter): Observable<IListResponse<IStorageConfigBasicInfo>>;
 }
 
 declare enum IconTypeEnum {
-    PRIMENG_ICON = 1,
-    IMAGE_FILE_LINK = 2,
-    DIRECT_TAG_SVG = 3
+    ICON_NAME = 1,
+    IMAGE_FILE_LINK = 2
 }
 
 declare class CookieService {
@@ -780,15 +621,17 @@ declare class CookieService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<CookieService>;
 }
 
-/**
- * Request DTO for fetching file URLs
- */
-interface GetFilesRequestDto {
-    id: string;
+declare class FaviconService {
+    private readonly http;
+    private readonly platformService;
+    private readonly document;
+    private svgTemplate;
+    apply(): void;
+    private render;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FaviconService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FaviconService>;
 }
-/**
- * Response DTO with file information including URL
- */
+
 interface FilesResponseDto {
     id: string;
     name: string;
@@ -797,113 +640,40 @@ interface FilesResponseDto {
 }
 /**
  * Service to fetch file URLs from the backend.
- * Uses POST /file-manager/get-files endpoint which:
- * - Handles presigned URLs for cloud storage (AWS S3, Azure)
- * - Auto-refreshes expired URLs
- * - Validates file access permissions
- * - Works with all storage providers (Local, S3, Azure, SFTP)
+ * Handles presigned URLs for cloud storage, auto-refresh, and caching.
  */
 declare class FileUrlService {
     private readonly http;
     private readonly appConfig;
-    /** Cache of file URLs by file ID */
-    private readonly urlCache;
-    /**
-     * Get file URL by ID from cache (reactive signal)
-     */
-    getFileUrl(fileId: string | null | undefined): string | null;
-    /**
-     * Get file URL signal (computed from cache)
-     */
-    fileUrlSignal(fileId: string | null | undefined): _angular_core.Signal<string | null>;
-    /**
-     * Fetch file URLs from backend and update cache.
-     * Skips IDs already in cache to prevent duplicate calls.
-     * Returns Observable of fetched files (including cached ones).
-     */
+    private readonly _cache;
+    readonly cache: _angular_core.Signal<Map<string, FilesResponseDto>>;
+    /** Fetch file URLs from backend and update cache */
     fetchFileUrls(fileIds: string[], forceRefresh?: boolean): Observable<FilesResponseDto[]>;
-    /**
-     * Fetch a single file URL.
-     * Uses cache if available to prevent duplicate calls.
-     * Returns Observable of file info or null if not found.
-     */
+    /** Fetch single file URL (delegates to fetchFileUrls) */
     fetchSingleFileUrl(fileId: string, forceRefresh?: boolean): Observable<FilesResponseDto | null>;
-    /**
-     * Clear the URL cache.
-     * Useful on logout or when switching contexts.
-     */
-    clearCache(): void;
-    /**
-     * Remove specific file from cache.
-     */
-    removeFromCache(fileId: string): void;
+    private addToCache;
+    private getFromCache;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUrlService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<FileUrlService>;
 }
 
 /**
- * Permission Validator Service
- *
- * Centralized service for permission validation across all packages.
- * Provides signal-based state management and reactive permission checking.
- *
- * Features:
- * - Signal-based permission storage
- * - Individual permission checks
- * - Permission change detection
- * - Reactive permission state updates
- *
- * Usage:
- * ```typescript
- * // In component
- * readonly permissionValidator = inject(PermissionValidatorService);
- *
- * // Set permissions (typically from auth/IAM)
- * this.permissionValidator.setPermissions(['user.view', 'user.create']);
- *
- * // Check individual permission
- * if (this.permissionValidator.hasPermission('user.view')) {
- *   // Show UI element
- * }
- *
- * // Access current permissions reactively
- * const permissions = this.permissionValidator.permissions();
- * ```
- *
- * @packageDocumentation
+ * Permission state management service.
+ * Provides signal-based storage and permission checking with wildcard support.
  */
 declare class PermissionValidatorService {
-    /**
-     * Private writable signal for permissions
-     */
     private readonly _permissions;
-    /**
-     * Readonly permission signal for external consumers
-     */
     readonly permissions: _angular_core.Signal<string[]>;
-    /**
-     * Private writable signal for loaded state
-     */
     private readonly _isLoaded;
-    /**
-     * Set permissions (replaces existing permissions)
-     * @param permissions - Array of permission codes
-     */
+    readonly isLoaded: _angular_core.Signal<boolean>;
+    /** Set permissions (replaces existing) */
     setPermissions(permissions: string[]): void;
-    /**
-     * Clear all permissions
-     */
+    /** Clear all permissions */
     clearPermissions(): void;
-    /**
-     * Check if user has a specific permission
-     * @param permissionCode - Required permission code
-     * @returns True if user has permission
-     */
-    hasPermission(permissionCode: string): boolean;
-    /**
-     * Check if permissions are loaded
-     * @returns True if permissions have been loaded
-     */
+    /** Check if user has permission (supports wildcards: '*', 'module.*') */
+    hasPermission(code: string): boolean;
+    /** Check if user has ANY of the specified permissions (OR logic) */
+    hasAnyPermission(code: string[]): boolean;
     isPermissionsLoaded(): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PermissionValidatorService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PermissionValidatorService>;
@@ -916,6 +686,16 @@ declare class PlatformService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlatformService>;
 }
 
+declare class TranslateService {
+    private readonly localizationState;
+    private readonly registry;
+    translate(key: string, params?: Record<string, string | unknown>): string;
+    translateSignal(key: string, params?: Record<string, string | number>): Signal<string>;
+    private interpolate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TranslateService>;
+}
+
 declare class EditModeElementChangerDirective {
     private readonly el;
     private readonly ngControl;
@@ -954,20 +734,18 @@ declare class EditModeElementChangerDirective {
  * @example
  * // In component
  * readonly userManageLogic: ILogicNode = {
- *   id: 'root',
  *   type: 'group',
  *   operator: 'AND',
  *   children: [
  *     {
- *       id: '1',
  *       type: 'group',
  *       operator: 'OR',
  *       children: [
- *         { id: '2', type: 'action', actionId: 'user.view' },
- *         { id: '3', type: 'action', actionId: 'user.create' }
+ *         { type: 'action', actionId: 'user.view' },
+ *         { type: 'action', actionId: 'user.create' }
  *       ]
  *     },
- *     { id: '4', type: 'action', actionId: 'department.manage' }
+ *     { type: 'action', actionId: 'department.manage' }
  *   ]
  * };
  *
@@ -1015,9 +793,9 @@ declare class IsEmptyImageDirective {
 }
 
 declare class PreventDefaultDirective {
-    eventType: _angular_core.InputSignal<"click" | "keydown" | "keyup">;
-    preventKey: _angular_core.InputSignal<string | undefined>;
-    action: _angular_core.OutputEmitterRef<Event>;
+    readonly eventType: _angular_core.InputSignal<"click" | "keydown" | "keyup">;
+    readonly preventKey: _angular_core.InputSignal<string | undefined>;
+    readonly action: _angular_core.OutputEmitterRef<Event>;
     onClick(event: MouseEvent): void;
     onKeydown(event: KeyboardEvent): void;
     onKeyup(event: KeyboardEvent): void;
@@ -1026,206 +804,458 @@ declare class PreventDefaultDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PreventDefaultDirective, "[appPreventDefault]", never, { "eventType": { "alias": "eventType"; "required": false; "isSignal": true; }; "preventKey": { "alias": "preventKey"; "required": false; "isSignal": true; }; }, { "action": "action"; }, never, never, true, never>;
 }
 
-declare class AngularModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AngularModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AngularModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.RouterOutlet, typeof i3.RouterLink, typeof IsEmptyImageDirective, typeof i1.NgOptimizedImage, typeof i1.NgComponentOutlet, typeof PreventDefaultDirective], [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.RouterOutlet, typeof i3.RouterLink, typeof IsEmptyImageDirective, typeof i1.NgOptimizedImage, typeof i1.NgComponentOutlet, typeof PreventDefaultDirective]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AngularModule>;
-}
-
-declare class PrimeModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PrimeModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<PrimeModule, never, never, [typeof i1$1.AutoCompleteModule, typeof i2$1.AvatarModule, typeof i3$1.ButtonModule, typeof i4.CardModule, typeof i5.CheckboxModule, typeof i6.ConfirmDialogModule, typeof i7.DatePickerModule, typeof i8.DialogModule, typeof i9.DividerModule, typeof i10.FileUploadModule, typeof i11.IconFieldModule, typeof i12.ImageModule, typeof i13.InputIconModule, typeof i14.InputNumberModule, typeof i15.InputTextModule, typeof i16.ListboxModule, typeof i17.MultiSelectModule, typeof i18.PaginatorModule, typeof i19.PanelModule, typeof i20.PasswordModule, typeof i21.PopoverModule, typeof i22.ProgressBarModule, typeof i23.RadioButtonModule, typeof i24.RippleModule, typeof i25.SelectButtonModule, typeof i26.SelectModule, typeof i27.SkeletonModule, typeof i28.SplitButtonModule, typeof i29.StepsModule, typeof i30.TableModule, typeof i31.TabsModule, typeof i32.TagModule, typeof i33.TextareaModule, typeof i34.ToastModule, typeof i35.ToggleSwitchModule, typeof i36.TooltipModule, typeof i37.TreeTableModule]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<PrimeModule>;
+declare class TranslatePipe implements PipeTransform {
+    private readonly translateAdapter;
+    transform(key: string | null | undefined, params?: Record<string, string | number> | null, fallback?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TranslatePipe, "translate", true>;
 }
 
 /**
- * Service interface for CRUD operations.
- * Matches NestJS shared API controller endpoints:
+ * HTTP context token to skip global error toast.
+ * Use when component handles error display locally.
  *
- * | Angular Method   | HTTP   | NestJS Endpoint        | Response Type          |
- * |------------------|--------|------------------------|------------------------|
- * | insert()         | POST   | /{resource}/insert     | ISingleResponse<T>     |
- * | insertMany()     | POST   | /{resource}/insert-many| IBulkResponse<T>       |
- * | findById()       | POST   | /{resource}/get/:id    | ISingleResponse<T>     |
- * | getAll()         | POST   | /{resource}/get-all    | IListResponse<T>       |
- * | update()         | POST   | /{resource}/update     | ISingleResponse<T>     |
- * | updateMany()     | POST   | /{resource}/update-many| IBulkResponse<T>       |
- * | delete()         | POST   | /{resource}/delete     | IMessageResponse       |
+ * @example
+ * ```typescript
+ * this.http.post(url, data, {
+ *   context: new HttpContext().set(SKIP_ERROR_TOAST, true)
+ * });
+ * ```
  */
-interface IApiService<DtoT, InterfaceT> {
-    insert(dto: DtoT): Observable<ISingleResponse<InterfaceT>>;
-    insertMany(dtos: DtoT[]): Observable<IBulkResponse<InterfaceT>>;
-    findById(id: string, select?: string[]): Observable<ISingleResponse<InterfaceT>>;
-    getAll(search: string, filter: IFilterData): Observable<IListResponse<InterfaceT>>;
-    update(dto: DtoT): Observable<ISingleResponse<InterfaceT>>;
-    updateMany(dtos: DtoT[]): Observable<IBulkResponse<InterfaceT>>;
-    delete(deleteDto: IDeleteData): Observable<IMessageResponse>;
-}
+declare const SKIP_ERROR_TOAST: HttpContextToken<boolean>;
 /**
- * Abstract base class for API services using Angular 21 resource() API.
- * Provides signal-based reactive data fetching with automatic loading states.
- * Response types match FLUSYS_NEST backend DTOs.
+ * Error Catching Interceptor
+ * Displays error messages for failed HTTP requests using backend response.
  *
- * ## Endpoint Mapping
+ * Features:
+ * - Uses backend's error title (error.error.error) as summary
+ * - Uses backend's error message (error.error.message) as detail
+ * - Falls back to sensible defaults based on status code
+ * - Skip with SKIP_ERROR_TOAST context token for local handling
  *
- * All endpoints use POST method (RPC-style API):
- * - `POST /{resource}/insert`       - Create single item
- * - `POST /{resource}/insert-many`  - Create multiple items
- * - `POST /{resource}/get/:id`      - Get single item by ID
- * - `POST /{resource}/get-all?q=`   - List with pagination/filter
- * - `POST /{resource}/update`       - Update single item
- * - `POST /{resource}/update-many`  - Update multiple items
- * - `POST /{resource}/delete`       - Delete/restore/permanent delete
+ * NOTE: This interceptor only handles error display.
+ * For 401 handling and token refresh, use tokenRefreshInterceptor from @flusys/ng-auth.
  *
  * @example
  * ```typescript
- * // Define service
- * @Injectable({ providedIn: 'root' })
- * export class UserService extends ApiResourceService<UserDto, User> {
- *   constructor(http: HttpClient) {
- *     super('users', http);
- *   }
- * }
- *
- * // In component - use signals
- * userService = inject(UserService);
- * users = this.userService.data;              // Signal<User[]>
- * isLoading = this.userService.isLoading;     // Signal<boolean>
- * total = this.userService.total;             // Signal<number>
- *
- * // Trigger fetch
- * this.userService.fetchList('search', { pagination: { currentPage: 0, pageSize: 10 } });
- *
- * // CRUD operations
- * await this.userService.insertAsync({ name: 'John', email: 'john@example.com' });
- * await this.userService.updateAsync({ id: '123', name: 'John Updated' });
- * await this.userService.deleteAsync({ id: '123', type: 'delete' });
+ * // In app.config.ts
+ * provideHttpClient(
+ *   withFetch(),
+ *   withInterceptors([
+ *     authInterceptor,           // from @flusys/ng-auth
+ *     tokenRefreshInterceptor,   // from @flusys/ng-auth
+ *     errorCatchingInterceptor,  // from @flusys/ng-core
+ *     apiLoaderInterceptor,      // from @flusys/ng-core
+ *   ])
+ * )
  * ```
  */
+declare function errorCatchingInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;
+
+interface IResolverModuleConfig {
+    modules: string[];
+    fallbackMessages?: Record<string, string>;
+}
+declare function resolveTranslationModule(config: IResolverModuleConfig): ResolveFn<boolean>;
+
+declare class AngularModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AngularModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AngularModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.RouterOutlet, typeof i3.RouterLink, typeof i3.RouterLinkActive, typeof IsEmptyImageDirective, typeof i1.NgOptimizedImage, typeof i1.NgComponentOutlet, typeof PreventDefaultDirective], [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.RouterOutlet, typeof i3.RouterLink, typeof i3.RouterLinkActive, typeof IsEmptyImageDirective, typeof i1.NgOptimizedImage, typeof i1.NgComponentOutlet, typeof PreventDefaultDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AngularModule>;
+}
+
+interface IApiService<DtoT, InterfaceT> {
+    insert(dto: DtoT): Promise<ISingleResponse<InterfaceT>>;
+    insertMany(dtos: DtoT[]): Promise<IBulkResponse<InterfaceT>>;
+    findById(id: string, select?: string[]): Promise<ISingleResponse<InterfaceT>>;
+    findByIds(ids: string[], select?: string[] | string): Promise<IListResponse<InterfaceT>>;
+    getAll(filter: IFilterData, search?: string): Promise<IListResponse<InterfaceT>>;
+    getByFilter(filter: Record<string, unknown>): Promise<ISingleResponse<InterfaceT>>;
+    update(dto: DtoT): Promise<ISingleResponse<InterfaceT>>;
+    updateMany(dtos: DtoT[]): Promise<IBulkResponse<InterfaceT>>;
+    bulkUpsert(toInsert: DtoT[], toUpdate: DtoT[]): Promise<InterfaceT[]>;
+    delete(deleteDto: IDeleteData): Promise<IMessageResponse>;
+}
 declare abstract class ApiResourceService<DtoT, InterfaceT> implements IApiService<DtoT, InterfaceT> {
-    protected readonly baseUrl: string;
-    protected readonly loaderService: ApiLoaderService;
-    protected readonly injector: Injector;
     protected readonly http: HttpClient;
+    private readonly _config;
+    protected readonly baseUrl: string;
     protected readonly moduleApiName: string;
-    /** Current search term */
     readonly searchTerm: _angular_core.WritableSignal<string>;
-    /** Current filter and pagination state */
     readonly filterData: _angular_core.WritableSignal<IFilterData>;
-    /**
-     * Resource for list data - lazy initialized to prevent auto-fetch on service injection.
-     * Call initListResource() or any list method (fetchList, reload, etc.) to initialize.
-     */
-    private _listResource;
-    /** Whether the list resource has been initialized */
-    private _resourceInitialized;
-    /** Get or create the list resource (lazy initialization) */
-    get listResource(): ResourceRef<IListResponse<InterfaceT> | undefined>;
-    /**
-     * Initialize the list resource. Called automatically when accessing listResource
-     * or any list-related computed signals/methods.
-     * Uses runInInjectionContext to support lazy initialization outside constructor.
-     */
-    initListResource(): void;
-    /** Whether data is currently loading */
+    private readonly _active;
+    readonly listResource: ResourceRef<IListResponse<InterfaceT> | undefined>;
     readonly isLoading: _angular_core.Signal<boolean>;
-    /** List data array */
     readonly data: _angular_core.Signal<InterfaceT[]>;
-    /** Total count of items */
     readonly total: _angular_core.Signal<number>;
-    /** Pagination metadata */
     readonly pageInfo: _angular_core.Signal<_flusys_ng_shared.IPaginationMeta | undefined>;
-    /** Whether there are more pages */
     readonly hasMore: _angular_core.Signal<boolean>;
-    constructor(moduleApiName: string, http: HttpClient);
+    readonly error: _angular_core.Signal<Error | undefined>;
+    readonly status: _angular_core.Signal<ResourceStatus>;
+    constructor(moduleApiName: string, serviceName?: ServiceName);
     protected getHttpOptions(endpoint: string, params?: HttpParams): {
         params?: HttpParams | undefined;
         headers: HttpHeaders;
     };
-    /**
-     * Fetch list data (triggers resource initialization and reload)
-     */
+    private _getAllObs;
+    private _activate;
     fetchList(search?: string, filter?: Partial<IFilterData>): void;
-    /**
-     * Update pagination
-     */
     setPagination(pagination: IPagination): void;
-    /**
-     * Go to next page
-     */
     nextPage(): void;
-    /**
-     * Reset to first page
-     */
     resetPagination(): void;
-    /**
-     * Reload current data
-     */
     reload(): void;
+    private _post;
+    insert(dto: DtoT): Promise<ISingleResponse<InterfaceT>>;
+    insertMany(dtos: DtoT[]): Promise<IBulkResponse<InterfaceT>>;
+    findById(id: string, select?: string[]): Promise<ISingleResponse<InterfaceT>>;
+    getAll(filter: IFilterData, search?: string): Promise<IListResponse<InterfaceT>>;
+    update(dto: DtoT): Promise<ISingleResponse<InterfaceT>>;
+    updateMany(dtos: DtoT[]): Promise<IBulkResponse<InterfaceT>>;
+    delete(deleteDto: IDeleteData): Promise<IMessageResponse>;
+    findByIds(ids: string[], select?: string[] | string): Promise<IListResponse<InterfaceT>>;
+    getByFilter(filter: Record<string, unknown>): Promise<ISingleResponse<InterfaceT>>;
+    bulkUpsert(toInsert: DtoT[], toUpdate: DtoT[]): Promise<InterfaceT[]>;
+}
+
+declare abstract class BaseFormControl<T> implements ControlValueAccessor, FormValueControl<T> {
+    protected readonly injector: Injector;
+    abstract readonly value: ReturnType<typeof model<T>>;
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    private onChange;
+    private onTouched;
+    private writeDepth;
     /**
-     * Insert single item (Observable)
-     * POST /{resource}/insert
-     */
-    insert(dto: DtoT): Observable<ISingleResponse<InterfaceT>>;
-    /**
-     * Insert multiple items (Observable)
-     * POST /{resource}/insert-many
-     */
-    insertMany(dtos: DtoT[]): Observable<IBulkResponse<InterfaceT>>;
-    /**
-     * Find single item by ID (Observable)
-     * POST /{resource}/get/:id
-     */
-    findById(id: string, select?: string[]): Observable<ISingleResponse<InterfaceT>>;
-    /**
-     * Get all items with pagination (Observable)
-     * POST /{resource}/get-all?q=search
-     */
-    getAll(search: string, filter: IFilterData): Observable<IListResponse<InterfaceT>>;
-    /**
-     * Update single item (Observable)
-     * POST /{resource}/update
-     */
-    update(dto: DtoT): Observable<ISingleResponse<InterfaceT>>;
-    /**
-     * Update multiple items (Observable)
-     * POST /{resource}/update-many
-     */
-    updateMany(dtos: DtoT[]): Observable<IBulkResponse<InterfaceT>>;
-    /**
-     * Delete items (Observable)
-     * POST /{resource}/delete
-     * @param deleteDto - { id: string | string[], type: 'delete' | 'restore' | 'permanent' }
-     */
-    delete(deleteDto: IDeleteData): Observable<IMessageResponse>;
-    /**
-     * Fetch paginated list (async)
-     */
-    protected fetchAllAsync(search: string, filter: IFilterData): Promise<IListResponse<InterfaceT>>;
-    /**
-     * Find single item by ID (async)
-     */
-    findByIdAsync(id: string, select?: string[]): Promise<ISingleResponse<InterfaceT>>;
-    /**
-     * Insert single item (async)
-     */
-    insertAsync(dto: DtoT): Promise<ISingleResponse<InterfaceT>>;
-    /**
-     * Insert multiple items (async)
-     */
-    insertManyAsync(dtos: DtoT[]): Promise<IBulkResponse<InterfaceT>>;
-    /**
-     * Update single item (async)
-     */
-    updateAsync(dto: DtoT): Promise<ISingleResponse<InterfaceT>>;
-    /**
-     * Update multiple items (async)
-     */
-    updateManyAsync(dtos: DtoT[]): Promise<IBulkResponse<InterfaceT>>;
-    /**
-     * Delete items (async)
+     * Wire up the ControlValueAccessor ↔ signal bridge.
+     * Call once at the end of the subclass constructor.
+     *
+     * Signal-form consumers ([formField]) don't need this — Angular's
+     * FormField directive binds directly to `value`.
+     *
+     * @example
+     * constructor() { super(); this.initializeFormControl(); }
      */
-    deleteAsync(deleteDto: IDeleteData): Promise<IMessageResponse>;
+    protected initializeFormControl(): void;
+    writeValue(value: T): void;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Call on blur / panel-close to propagate touched state. */
+    protected markAsTouched(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseFormControl<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseFormControl<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+/**
+ * Factory function to provide NG_VALUE_ACCESSOR for a component.
+ * Use in component providers array.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [provideValueAccessor(LazySelectComponent)]
+ * })
+ * export class LazySelectComponent extends BaseFormControl<string | null> {}
+ * ```
+ */
+declare function provideValueAccessor<T extends new (...args: unknown[]) => ControlValueAccessor>(component: T): {
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+};
+
+declare class BaseFormTemplateDirective {
+    readonly key: _angular_core.InputSignal<string>;
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseFormTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseFormTemplateDirective, "ng-template[baseFormTemplate]", never, { "key": { "alias": "baseFormTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type FormFieldType = 'text' | 'email' | 'password' | 'number' | 'textarea' | 'select' | 'multiselect' | 'date' | 'checkbox' | 'toggle' | 'custom';
+interface IFormSelectOption {
+    label: string;
+    value: unknown;
+}
+interface IFormField {
+    key: string;
+    type: FormFieldType;
+    label: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    options?: IFormSelectOption[];
+    minDate?: Date;
+    maxDate?: Date;
+    rows?: number;
+    min?: number;
+    max?: number;
+    hint?: string;
+}
+
+declare class BaseFormComponent {
+    private readonly translateAdapter;
+    private readonly router;
+    private readonly messageService;
+    readonly fields: _angular_core.InputSignal<IFormField[]>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly createTitle: _angular_core.InputSignal<string>;
+    readonly editTitle: _angular_core.InputSignal<string>;
+    readonly columns: _angular_core.InputSignal<1 | 2 | 3>;
+    readonly submitLabel: _angular_core.InputSignal<string>;
+    readonly cancelLabel: _angular_core.InputSignal<string>;
+    readonly isLoading: _angular_core.InputSignal<boolean>;
+    readonly isEditMode: _angular_core.InputSignal<boolean>;
+    readonly initialValue: _angular_core.InputSignal<Record<string, unknown>>;
+    readonly service: _angular_core.InputSignal<ApiResourceService<unknown, unknown> | null>;
+    readonly editId: _angular_core.InputSignal<string | null>;
+    readonly cancelRoute: _angular_core.InputSignal<string | string[] | null>;
+    readonly navigateOnSuccess: _angular_core.InputSignal<string | string[] | null>;
+    readonly mapToRequest: _angular_core.InputSignal<((data: Record<string, unknown>, editId: string | null) => unknown) | null>;
+    readonly mapFromEntity: _angular_core.InputSignal<((entity: unknown) => Record<string, unknown>) | null>;
+    readonly onSubmit: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    readonly onCancel: _angular_core.OutputEmitterRef<void>;
+    readonly onValueChange: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    readonly fieldTemplates: _angular_core.Signal<readonly BaseFormTemplateDirective[]>;
+    private readonly _formData;
+    private readonly _submitted;
+    private readonly _isLoadingInternal;
+    private readonly _touchedFields;
+    private readonly _visiblePasswordFields;
+    readonly formData: _angular_core.Signal<Record<string, unknown>>;
+    readonly submitted: _angular_core.Signal<boolean>;
+    readonly effectiveIsEditMode: _angular_core.Signal<boolean>;
+    readonly effectiveIsLoading: _angular_core.Signal<boolean>;
+    readonly isFormValid: _angular_core.Signal<boolean>;
+    readonly resolvedTitle: _angular_core.Signal<string>;
+    readonly gridClass: _angular_core.Signal<"grid-cols-1" | "grid-cols-1 md:grid-cols-3" | "grid-cols-1 md:grid-cols-2">;
+    constructor();
+    private loadEntity;
+    getFieldValue(key: string): unknown;
+    setFieldValue(key: string, value: unknown): void;
+    markFieldTouched(key: string): void;
+    isPasswordVisible(key: string): boolean;
+    togglePasswordVisibility(key: string): void;
+    isFieldInvalid(field: IFormField): boolean;
+    getFieldTemplate(key: string): TemplateRef<unknown> | null;
+    handleSubmit(): Promise<void>;
+    handleCancel(): void;
+    reset(): void;
+    t(key: string, vars?: Record<string, string | number>): string;
+    private managedSubmit;
+    private checkValidity;
+    private navigateTo;
+    private getDefaultValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseFormComponent, "lib-base-form", never, { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "createTitle": { "alias": "createTitle"; "required": false; "isSignal": true; }; "editTitle": { "alias": "editTitle"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "submitLabel": { "alias": "submitLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": false; "isSignal": true; }; "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; "service": { "alias": "service"; "required": false; "isSignal": true; }; "editId": { "alias": "editId"; "required": false; "isSignal": true; }; "cancelRoute": { "alias": "cancelRoute"; "required": false; "isSignal": true; }; "navigateOnSuccess": { "alias": "navigateOnSuccess"; "required": false; "isSignal": true; }; "mapToRequest": { "alias": "mapToRequest"; "required": false; "isSignal": true; }; "mapFromEntity": { "alias": "mapFromEntity"; "required": false; "isSignal": true; }; }, { "onSubmit": "onSubmit"; "onCancel": "onCancel"; "onValueChange": "onValueChange"; }, ["fieldTemplates"], never, true, never>;
+}
+
+declare class BaseListTemplateDirective {
+    readonly key: _angular_core.InputSignal<string>;
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseListTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseListTemplateDirective, "ng-template[baseListTemplate]", never, { "key": { "alias": "baseListTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type TableColumnType = 'text' | 'date' | 'tag' | 'boolean' | 'number' | 'custom';
+type ActionSeverity = 'success' | 'info' | 'warn' | 'danger' | 'secondary' | 'contrast';
+interface ITagConfig {
+    label?: string;
+    severity: 'success' | 'danger' | 'warn' | 'info' | 'secondary' | 'contrast';
+}
+interface ITableColumn {
+    field: string;
+    header: string;
+    type?: TableColumnType;
+    width?: string;
+    minWidth?: string;
+    align?: 'left' | 'center' | 'right';
+    tagMap?: Record<string, ITagConfig>;
+    dateFormat?: string;
+    truncate?: number;
+    hidden?: boolean;
+}
+interface ITableAction<T = unknown> {
+    icon: string;
+    tooltip?: string;
+    severity?: ActionSeverity;
+    show?: (item: T) => boolean;
+    disabled?: (item: T) => boolean;
+    handler: (item: T) => void;
+}
+
+declare class BaseListComponent {
+    private readonly translateAdapter;
+    private readonly router;
+    private readonly messageService;
+    private readonly confirmationService;
+    readonly columns: _angular_core.InputSignal<ITableColumn[]>;
+    readonly actions: _angular_core.InputSignal<ITableAction<unknown>[]>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly showCreateButton: _angular_core.InputSignal<boolean>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly createButtonLabel: _angular_core.InputSignal<string>;
+    readonly createButtonIcon: _angular_core.InputSignal<string>;
+    readonly data: _angular_core.InputSignal<unknown[]>;
+    readonly total: _angular_core.InputSignal<number>;
+    readonly isLoading: _angular_core.InputSignal<boolean>;
+    readonly service: _angular_core.InputSignal<ApiResourceService<unknown, unknown> | null>;
+    readonly filter: _angular_core.InputSignal<IFilter>;
+    readonly createRoute: _angular_core.InputSignal<string | null>;
+    readonly editRoute: _angular_core.InputSignal<string | null>;
+    readonly deleteConfirmField: _angular_core.InputSignal<string | null>;
+    readonly idField: _angular_core.InputSignal<string>;
+    readonly canEdit: _angular_core.InputSignal<((item: unknown) => boolean) | null>;
+    readonly canDelete: _angular_core.InputSignal<((item: unknown) => boolean) | null>;
+    readonly onCreate: _angular_core.OutputEmitterRef<void>;
+    readonly onLazyLoad: _angular_core.OutputEmitterRef<{
+        first: number;
+        rows: number;
+    }>;
+    readonly onSearch: _angular_core.OutputEmitterRef<string>;
+    readonly columnTemplates: _angular_core.Signal<readonly BaseListTemplateDirective[]>;
+    private readonly _first;
+    private readonly _searchTerm;
+    readonly first: _angular_core.Signal<number>;
+    readonly searchTerm: _angular_core.Signal<string>;
+    readonly effectiveData: _angular_core.Signal<unknown[]>;
+    readonly effectiveTotal: _angular_core.Signal<number>;
+    readonly effectiveIsLoading: _angular_core.Signal<boolean>;
+    readonly effectiveActions: _angular_core.Signal<ITableAction<unknown>[]>;
+    readonly visibleColumns: _angular_core.Signal<ITableColumn[]>;
+    readonly columnCount: _angular_core.Signal<number>;
+    readonly resolvedEmptyMessage: _angular_core.Signal<string>;
+    readonly resolvedCreateLabel: _angular_core.Signal<string>;
+    handleLazyLoad(event: {
+        first?: number | null;
+        rows?: number | null;
+    }): void;
+    onSearchChange(value: string): void;
+    handleCreate(): void;
+    private handleEditItem;
+    private handleDeleteItem;
+    getFieldValue(item: unknown, field: string): unknown;
+    getFieldValueAsString(item: unknown, field: string): string;
+    getTagConfig(col: ITableColumn, value: unknown): ITagConfig | null;
+    getColumnTemplate(field: string): TemplateRef<unknown> | null;
+    truncateText(value: unknown, limit?: number): string;
+    getCellClass(col: ITableColumn): string;
+    t(key: string, vars?: Record<string, string | number>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseListComponent, "lib-base-list", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "showCreateButton": { "alias": "showCreateButton"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "createButtonLabel": { "alias": "createButtonLabel"; "required": false; "isSignal": true; }; "createButtonIcon": { "alias": "createButtonIcon"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "service": { "alias": "service"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "createRoute": { "alias": "createRoute"; "required": false; "isSignal": true; }; "editRoute": { "alias": "editRoute"; "required": false; "isSignal": true; }; "deleteConfirmField": { "alias": "deleteConfirmField"; "required": false; "isSignal": true; }; "idField": { "alias": "idField"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "canDelete": { "alias": "canDelete"; "required": false; "isSignal": true; }; }, { "onCreate": "onCreate"; "onLazyLoad": "onLazyLoad"; "onSearch": "onSearch"; }, ["columnTemplates"], never, true, never>;
+}
+
+declare class FileSelectorDialogComponent {
+    private readonly destroyRef;
+    private readonly translateAdapter;
+    readonly fileProvider: _flusys_ng_shared.IFileProvider | null;
+    private abortController;
+    private searchDebounceTimer;
+    readonly header: _angular_core.InputSignal<string | undefined>;
+    readonly acceptTypes: _angular_core.InputSignal<string[]>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly dialogHeader: _angular_core.Signal<string>;
+    readonly maxSelection: _angular_core.InputSignal<number>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly folderId: _angular_core.InputSignal<string | undefined>;
+    readonly withUploader: _angular_core.InputSignal<boolean>;
+    readonly visible: _angular_core.ModelSignal<boolean>;
+    readonly fileSelected: _angular_core.OutputEmitterRef<IFileBasicInfo>;
+    readonly filesSelected: _angular_core.OutputEmitterRef<IFileBasicInfo[]>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly onError: _angular_core.OutputEmitterRef<Error>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly files: _angular_core.WritableSignal<IFileBasicInfo[]>;
+    readonly selectedFiles: _angular_core.WritableSignal<IFileBasicInfo[]>;
+    readonly total: _angular_core.WritableSignal<number | undefined>;
+    readonly pagination: _angular_core.WritableSignal<IPagination>;
+    readonly searchTerm: _angular_core.WritableSignal<string>;
+    readonly folders: _angular_core.WritableSignal<IFolderBasicInfo[]>;
+    readonly selectedFolderId: _angular_core.WritableSignal<string | null>;
+    readonly foldersLoading: _angular_core.WritableSignal<boolean>;
+    readonly foldersPagination: _angular_core.WritableSignal<IPagination>;
+    readonly foldersTotal: _angular_core.WritableSignal<number | undefined>;
+    readonly storageConfigs: _angular_core.WritableSignal<IStorageConfigBasicInfo[]>;
+    readonly selectedStorageConfigId: _angular_core.WritableSignal<string | null>;
+    readonly storageConfigsLoading: _angular_core.WritableSignal<boolean>;
+    readonly storageConfigsPagination: _angular_core.WritableSignal<IPagination>;
+    readonly storageConfigsTotal: _angular_core.WritableSignal<number | undefined>;
+    readonly effectiveStorageConfigId: _angular_core.Signal<string | undefined>;
+    readonly uploadFileFn: (file: File, options?: IFileUploadOptions) => rxjs.Observable<_flusys_ng_shared.ISingleResponse<IUploadedFile>>;
+    readonly uploadMultipleFilesFn: ((files: File[], options?: IFileUploadOptions) => rxjs.Observable<_flusys_ng_shared.ISingleResponse<IUploadedFile[]>>) | undefined;
+    constructor();
+    onSearchChange(value: string): void;
+    onScroll(event: Event): void;
+    toggleSelection(file: IFileBasicInfo): void;
+    isSelected(file: IFileBasicInfo): boolean;
+    isFileAllowed(file: IFileBasicInfo): boolean;
+    isImage(file: IFileBasicInfo): boolean;
+    getFileIcon(file: IFileBasicInfo): string;
+    formatSize(size: string): string;
+    onCancel(): void;
+    onConfirm(): void;
+    onDialogHide(): void;
+    onFolderChange(folderId: string | null): void;
+    onFolderSearch(event: {
+        filter: string;
+    }): void;
+    loadFolders(search?: string): Promise<void>;
+    onStorageConfigChange(configId: string | null): void;
+    onStorageConfigSearch(event: {
+        filter: string;
+    }): void;
+    loadStorageConfigs(search?: string): Promise<void>;
+    onFileUploaded(uploadedFile: IUploadedFile): void;
+    private resetState;
+    private fetchFiles;
+    private t;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileSelectorDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileSelectorDialogComponent, "lib-file-selector-dialog", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "acceptTypes": { "alias": "acceptTypes"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxSelection": { "alias": "maxSelection"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "folderId": { "alias": "folderId"; "required": false; "isSignal": true; }; "withUploader": { "alias": "withUploader"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "fileSelected": "fileSelected"; "filesSelected": "filesSelected"; "closed": "closed"; "onError": "onError"; }, never, never, true, never>;
+}
+
+declare class FileUploaderComponent {
+    private readonly messageService;
+    private readonly translateAdapter;
+    private readonly fileProvider;
+    readonly uploadFile: _angular_core.InputSignal<UploadFileFn | undefined>;
+    readonly uploadMultipleFiles: _angular_core.InputSignal<UploadMultipleFilesFn | undefined>;
+    readonly hasUploadCapability: _angular_core.Signal<boolean>;
+    private getUploadFn;
+    private getUploadMultipleFn;
+    readonly acceptTypes: _angular_core.InputSignal<string[]>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly maxFiles: _angular_core.InputSignal<number>;
+    readonly maxSizeMb: _angular_core.InputSignal<number>;
+    readonly uploadOptions: _angular_core.InputSignal<IFileUploadOptions>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly showPreview: _angular_core.InputSignal<boolean>;
+    readonly autoUpload: _angular_core.InputSignal<boolean>;
+    readonly fileUploaded: _angular_core.OutputEmitterRef<IUploadedFile>;
+    readonly filesUploaded: _angular_core.OutputEmitterRef<IUploadedFile[]>;
+    readonly onError: _angular_core.OutputEmitterRef<Error>;
+    readonly fileSelected: _angular_core.OutputEmitterRef<File[]>;
+    readonly isUploading: _angular_core.WritableSignal<boolean>;
+    readonly isDragOver: _angular_core.WritableSignal<boolean>;
+    readonly uploadProgress: _angular_core.WritableSignal<number>;
+    readonly uploadingFileName: _angular_core.WritableSignal<string>;
+    readonly selectedFiles: _angular_core.WritableSignal<File[]>;
+    readonly acceptString: _angular_core.Signal<string>;
+    readonly acceptTypesDisplay: _angular_core.Signal<string>;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onFileSelected(event: Event): void;
+    private handleFiles;
+    removeFile(file: File): void;
+    uploadFiles(files?: File[]): Promise<void>;
+    private uploadBatch;
+    private uploadSequential;
+    getFileIcon(file: File): string;
+    formatSize(bytes: number): string;
+    private t;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploaderComponent, "lib-file-uploader", never, { "uploadFile": { "alias": "uploadFile"; "required": false; "isSignal": true; }; "uploadMultipleFiles": { "alias": "uploadMultipleFiles"; "required": false; "isSignal": true; }; "acceptTypes": { "alias": "acceptTypes"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "maxSizeMb": { "alias": "maxSizeMb"; "required": false; "isSignal": true; }; "uploadOptions": { "alias": "uploadOptions"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showPreview": { "alias": "showPreview"; "required": false; "isSignal": true; }; "autoUpload": { "alias": "autoUpload"; "required": false; "isSignal": true; }; }, { "fileUploaded": "fileUploaded"; "filesUploaded": "filesUploaded"; "onError": "onError"; "fileSelected": "fileSelected"; }, never, never, true, never>;
 }
 
 declare class IconComponent {
@@ -1236,77 +1266,13 @@ declare class IconComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "lib-icon", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "iconType": { "alias": "iconType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/**
- * Base class for form controls that support ALL Angular form patterns:
- *
- * 1. **Template-driven forms:** `[(value)]="mySignal"` or `[(ngModel)]="myValue"`
- * 2. **Reactive forms:** `[formControl]="ctrl"` or `formControlName="field"`
- * 3. **Signal forms (Angular 21+):** `[formField]="formTree.field"`
- *
- * Implements both `ControlValueAccessor` (reactive forms) and `FormValueControl` (signal forms).
- *
- * @example
- * ```typescript
- * @Component({
- *   providers: [provideValueAccessor(MySelectComponent)]
- * })
- * export class MySelectComponent extends BaseFormControl<string | null> {
- *   override readonly value = model<string | null>(null);
- *
- *   constructor() {
- *     super();
- *     this.initializeFormControl();
- *   }
- * }
- *
- * // Usage:
- * // Template-driven: <my-select [(value)]="selectedId" />
- * // Reactive forms:  <my-select [formControl]="myControl" />
- * // Signal forms:    <my-select [formField]="formTree.myField" />
- * ```
- */
-declare abstract class BaseFormControl<T> implements ControlValueAccessor, FormValueControl<T> {
-    protected readonly injector: Injector;
-    /**
-     * The value model - must be overridden in subclass with model<T>().
-     * This property satisfies both:
-     * - FormValueControl interface (signal forms)
-     * - Internal state for ControlValueAccessor (reactive forms)
-     */
-    abstract readonly value: ReturnType<typeof model<T>>;
-    /**
-     * Disabled state model - bound to form control disabled state.
-     * Using model() to satisfy FormValueControl interface requirements.
-     */
-    readonly disabled: _angular_core.ModelSignal<boolean>;
-    /**
-     * Touched state model - for validation styling.
-     * Using model() to satisfy FormValueControl interface requirements.
-     */
-    readonly touched: _angular_core.ModelSignal<boolean>;
-    private onChange;
-    private onTouched;
-    private isWritingValue;
-    /**
-     * Initialize the form control synchronization for ControlValueAccessor.
-     * Must be called in the subclass constructor after super().
-     *
-     * Note: For signal forms ([formField]), this is not needed as
-     * the FormField directive binds directly to the value model.
-     */
-    protected initializeFormControl(): void;
-    /** ControlValueAccessor: Write value from form control to signal */
-    writeValue(value: T): void;
-    /** ControlValueAccessor: Register change callback */
-    registerOnChange(fn: (value: T) => void): void;
-    /** ControlValueAccessor: Register touched callback */
-    registerOnTouched(fn: () => void): void;
-    /** ControlValueAccessor: Set disabled state from form control */
-    setDisabledState(isDisabled: boolean): void;
-    /** Mark the control as touched (call on blur or panel close) */
-    protected markAsTouched(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseFormControl<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseFormControl<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "touched": "touchedChange"; }, never, never, true, never>;
+declare class InlineSvgComponent {
+    readonly src: _angular_core.InputSignal<string>;
+    private readonly http;
+    private readonly sanitizer;
+    readonly svg: _angular_core.ResourceRef<_angular_platform_browser.SafeHtml | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InlineSvgComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InlineSvgComponent, "inline-svg", never, { "src": { "alias": "src"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -1317,38 +1283,45 @@ declare abstract class BaseFormControl<T> implements ControlValueAccessor, FormV
  * - Reactive forms: `[formControl]="ctrl"` or `formControlName="field"`
  * - Signal forms: `[formField]="formTree.field"`
  */
-declare class LazyMultiSelectComponent extends BaseFormControl<string[] | null> {
+declare class LazyMultiSelectComponent extends BaseFormControl<string[] | null> implements OnDestroy {
+    private readonly document;
+    private readonly appRef;
+    private readonly translateAdapter;
+    private readonly onDocumentClickBound;
+    readonly pSelectRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    readonly overlayTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    private overlayViewRef;
     readonly placeHolder: _angular_core.InputSignal<string>;
+    readonly showClear: _angular_core.InputSignal<boolean>;
+    readonly displayPlaceholder: _angular_core.Signal<string>;
     readonly isEditMode: _angular_core.InputSignal<boolean>;
     readonly isLoading: _angular_core.InputSignal<boolean>;
     readonly total: _angular_core.InputSignal<number | undefined>;
     readonly pagination: _angular_core.InputSignal<IPagination>;
     readonly selectDataList: _angular_core.InputSignal<IDropDown[]>;
-    /** Two-way bound value using model() for signal forms compatibility */
     readonly value: _angular_core.ModelSignal<string[] | null>;
     readonly onSearch: _angular_core.OutputEmitterRef<string>;
     readonly onPagination: _angular_core.OutputEmitterRef<IPagination>;
     readonly searchTerm: _angular_core.WritableSignal<string>;
-    /** Computed: Display text for selected values (replaces getSelectedValue method) */
+    readonly openOptions: _angular_core.WritableSignal<boolean>;
     readonly selectedValueDisplay: _angular_core.Signal<string>;
-    /** Computed: Whether all items are selected (replaces isSelectAll signal) */
+    readonly hasSelectedValues: _angular_core.Signal<boolean>;
     readonly isSelectAll: _angular_core.Signal<boolean>;
     constructor();
-    private readonly onScrollBound;
-    readonly multiScrollContainer: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    ngOnDestroy(): void;
     onScroll(event: Event): void;
-    readonly pSelectRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
-    openOptions: _angular_core.WritableSignal<boolean>;
-    onSelectClick(event: Event): void;
+    onSelectClick(): void;
+    private openOverlay;
+    private closeOverlay;
     onOverlayClick(event: Event): void;
-    handleDocumentClick(event: MouseEvent): void;
-    isSelected(data: IDropDown): boolean | undefined;
-    key(option: IDropDown): string;
+    private handleDocumentClick;
+    isSelected(data: IDropDown): boolean;
     selectValue(event: CheckboxChangeEvent, option: IDropDown): void;
     changeSelectAll(event: CheckboxChangeEvent): void;
     clear(event: Event): void;
+    private t;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<LazyMultiSelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LazyMultiSelectComponent, "lib-lazy-multi-select", never, { "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": true; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": true; "isSignal": true; }; "selectDataList": { "alias": "selectDataList"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onSearch": "onSearch"; "onPagination": "onPagination"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LazyMultiSelectComponent, "lib-lazy-multi-select", never, { "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": true; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": true; "isSignal": true; }; "selectDataList": { "alias": "selectDataList"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onSearch": "onSearch"; "onPagination": "onPagination"; }, never, never, true, never>;
 }
 
 /**
@@ -1360,7 +1333,15 @@ declare class LazyMultiSelectComponent extends BaseFormControl<string[] | null>
  * - Signal forms: `[formField]="formTree.field"`
  */
 declare class LazySelectComponent extends BaseFormControl<string | null> {
+    private readonly destroyRef;
+    private readonly translateAdapter;
+    private readonly onScrollBound;
+    private scrollTargetEl;
+    private isDestroyed;
+    readonly scrollContainer: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     readonly placeHolder: _angular_core.InputSignal<string>;
+    readonly showClear: _angular_core.InputSignal<boolean>;
+    readonly displayPlaceholder: _angular_core.Signal<string>;
     readonly optionLabel: _angular_core.InputSignal<string>;
     readonly optionValue: _angular_core.InputSignal<string>;
     readonly isEditMode: _angular_core.InputSignal<boolean>;
@@ -1368,62 +1349,52 @@ declare class LazySelectComponent extends BaseFormControl<string | null> {
     readonly total: _angular_core.InputSignal<number | undefined>;
     readonly pagination: _angular_core.InputSignal<IPagination>;
     readonly selectDataList: _angular_core.InputSignal<IDropDown[]>;
-    /** Two-way bound value using model() for signal forms compatibility */
     readonly value: _angular_core.ModelSignal<string | null>;
     readonly onSearch: _angular_core.OutputEmitterRef<string>;
     readonly onPagination: _angular_core.OutputEmitterRef<IPagination>;
     readonly searchTerm: _angular_core.WritableSignal<string>;
+    readonly isPanelShow: _angular_core.WritableSignal<boolean>;
     constructor();
-    isPanelShow: _angular_core.WritableSignal<boolean>;
-    scrollTargetEl: HTMLElement | null;
-    private readonly onScrollBound;
-    readonly scrollContainer: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     onScroll(event: Event): void;
     showPanel(): void;
     onBlur(): void;
+    private t;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<LazySelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LazySelectComponent, "lib-lazy-select", never, { "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": true; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": true; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": true; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": true; "isSignal": true; }; "selectDataList": { "alias": "selectDataList"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onSearch": "onSearch"; "onPagination": "onPagination"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LazySelectComponent, "lib-lazy-select", never, { "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": true; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": true; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": true; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": true; "isSignal": true; }; "selectDataList": { "alias": "selectDataList"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onSearch": "onSearch"; "onPagination": "onPagination"; }, never, never, true, never>;
+}
+
+interface RouterTabItem {
+    id: string | number;
+    label: string;
+    icon?: string;
+    route: string | unknown[];
+    routerLinkActiveExact?: boolean;
+}
+declare class RouterTabsComponent {
+    readonly tabs: _angular_core.InputSignal<RouterTabItem[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RouterTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RouterTabsComponent, "lib-router-tabs", never, { "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
- * User Select Component - Single user selection with lazy loading.
- *
- * Uses USER_PROVIDER internally by default, or accepts custom `loadUsers` function.
- *
- * Features:
- * - Search with debouncing (handled by lazy-select)
- * - Infinite scroll pagination
- * - Filter active users by default (configurable)
- * - Supports additional filters via `additionalFilters` input
- *
- * @example
- * ```html
- * <!-- Simple usage - uses USER_PROVIDER internally -->
- * <lib-user-select
- *   [(value)]="selectedUserId"
- *   [isEditMode]="true"
- * />
+ * Base class for user selection components.
+ * Provides shared user loading, pagination, and search functionality.
  *
- * <!-- With custom loadUsers function -->
- * <lib-user-select
- *   [(value)]="selectedUserId"
- *   [isEditMode]="true"
- *   [loadUsers]="customLoadUsers"
- * />
- * ```
+ * Subclasses must implement:
+ * - `setupValueEffect()` to track value changes and emit selection events
  */
-declare class UserSelectComponent {
-    private readonly destroyRef;
-    private readonly userProvider;
-    private abortController;
+declare abstract class BaseUserSelectComponent {
+    protected readonly destroyRef: DestroyRef;
+    protected readonly injector: Injector;
+    protected readonly userProvider: IUserProvider;
+    protected readonly translateAdapter: TranslateService;
+    protected abortController: AbortController | null;
     readonly loadUsers: _angular_core.InputSignal<LoadUsersFn | undefined>;
     readonly placeHolder: _angular_core.InputSignal<string>;
     readonly isEditMode: _angular_core.InputSignal<boolean>;
     readonly filterActive: _angular_core.InputSignal<boolean>;
     readonly additionalFilters: _angular_core.InputSignal<Record<string, unknown>>;
     readonly pageSize: _angular_core.InputSignal<number>;
-    readonly value: _angular_core.ModelSignal<string | null>;
-    readonly userSelected: _angular_core.OutputEmitterRef<IUserBasicInfo | null>;
     readonly onError: _angular_core.OutputEmitterRef<Error>;
     readonly isLoading: _angular_core.WritableSignal<boolean>;
     readonly users: _angular_core.WritableSignal<IUserBasicInfo[]>;
@@ -1431,16 +1402,20 @@ declare class UserSelectComponent {
     readonly pagination: _angular_core.WritableSignal<IPagination>;
     readonly searchTerm: _angular_core.WritableSignal<string>;
     readonly dropdownUsers: _angular_core.Signal<IDropDown[]>;
+    readonly displayPlaceholder: _angular_core.Signal<string>;
     constructor();
+    /** Setup effect to track value changes and emit selection events */
+    protected abstract setupValueEffect(): void;
     handleSearch(search: string): void;
     handlePagination(pagination: IPagination): void;
-    private fetchUsers;
-    /** Load users from USER_PROVIDER with active filter */
-    private loadUsersFromProvider;
     /** Reload users (useful when filters change externally) */
     reload(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserSelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserSelectComponent, "lib-user-select", never, { "loadUsers": { "alias": "loadUsers"; "required": false; "isSignal": true; }; "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; "filterActive": { "alias": "filterActive"; "required": false; "isSignal": true; }; "additionalFilters": { "alias": "additionalFilters"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "userSelected": "userSelected"; "onError": "onError"; }, never, never, true, never>;
+    protected fetchUsers(append?: boolean): Promise<void>;
+    /** Load users from USER_PROVIDER with active filter */
+    private loadUsersFromProvider;
+    protected t(key: string, variables?: Record<string, string | number>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseUserSelectComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseUserSelectComponent, never, never, { "loadUsers": { "alias": "loadUsers"; "required": false; "isSignal": true; }; "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; "filterActive": { "alias": "filterActive"; "required": false; "isSignal": true; }; "additionalFilters": { "alias": "additionalFilters"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, { "onError": "onError"; }, never, never, true, never>;
 }
 
 /**
@@ -1471,195 +1446,49 @@ declare class UserSelectComponent {
  * />
  * ```
  */
-declare class UserMultiSelectComponent {
-    private readonly destroyRef;
-    private readonly userProvider;
-    private abortController;
-    readonly loadUsers: _angular_core.InputSignal<LoadUsersFn | undefined>;
-    readonly placeHolder: _angular_core.InputSignal<string>;
-    readonly isEditMode: _angular_core.InputSignal<boolean>;
-    readonly filterActive: _angular_core.InputSignal<boolean>;
-    readonly additionalFilters: _angular_core.InputSignal<Record<string, unknown>>;
-    readonly pageSize: _angular_core.InputSignal<number>;
+declare class UserMultiSelectComponent extends BaseUserSelectComponent {
+    readonly showClear: _angular_core.InputSignal<boolean>;
     readonly value: _angular_core.ModelSignal<string[] | null>;
     readonly usersSelected: _angular_core.OutputEmitterRef<IUserBasicInfo[]>;
-    readonly onError: _angular_core.OutputEmitterRef<Error>;
-    readonly isLoading: _angular_core.WritableSignal<boolean>;
-    readonly users: _angular_core.WritableSignal<IUserBasicInfo[]>;
-    readonly total: _angular_core.WritableSignal<number | undefined>;
-    readonly pagination: _angular_core.WritableSignal<IPagination>;
-    readonly searchTerm: _angular_core.WritableSignal<string>;
-    readonly dropdownUsers: _angular_core.Signal<IDropDown[]>;
-    constructor();
-    handleSearch(search: string): void;
-    handlePagination(pagination: IPagination): void;
-    private fetchUsers;
-    /** Load users from USER_PROVIDER with active filter */
-    private loadUsersFromProvider;
-    /** Reload users (useful when filters change externally) */
-    reload(): void;
+    protected setupValueEffect(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserMultiSelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserMultiSelectComponent, "lib-user-multi-select", never, { "loadUsers": { "alias": "loadUsers"; "required": false; "isSignal": true; }; "placeHolder": { "alias": "placeHolder"; "required": false; "isSignal": true; }; "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; "filterActive": { "alias": "filterActive"; "required": false; "isSignal": true; }; "additionalFilters": { "alias": "additionalFilters"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "usersSelected": "usersSelected"; "onError": "onError"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserMultiSelectComponent, "lib-user-multi-select", never, { "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "usersSelected": "usersSelected"; }, never, never, true, never>;
 }
 
 /**
- * File Uploader Component - Drag & drop file upload with type filtering.
+ * User Select Component - Single user selection with lazy loading.
  *
- * Pass your own `uploadFile` function - works with any storage API.
+ * Uses USER_PROVIDER internally by default, or accepts custom `loadUsers` function.
  *
  * Features:
- * - Drag & drop support
- * - File type filtering (images, documents, etc.)
- * - Upload progress indication
- * - Multiple file support (optional)
- * - Image compression options
+ * - Search with debouncing (handled by lazy-select)
+ * - Infinite scroll pagination
+ * - Filter active users by default (configurable)
+ * - Supports additional filters via `additionalFilters` input
  *
  * @example
- * ```typescript
- * // In component
- * readonly uploadService = inject(UploadService);
- *
- * readonly uploadFile: UploadFileFn = (file, options) =>
- *   this.uploadService.uploadSingleFile(file, options);
- * ```
- *
  * ```html
- * <!-- Single image upload -->
- * <lib-file-uploader
- *   [uploadFile]="uploadFile"
- *   [acceptTypes]="['image/*']"
- *   [multiple]="false"
- *   (fileUploaded)="onFileUploaded($event)"
- * />
- *
- * <!-- Multiple document upload -->
- * <lib-file-uploader
- *   [uploadFile]="uploadFile"
- *   [acceptTypes]="FILE_TYPE_FILTERS.DOCUMENTS"
- *   [multiple]="true"
- *   [maxFiles]="5"
- *   (filesUploaded)="onFilesUploaded($event)"
+ * <!-- Simple usage - uses USER_PROVIDER internally -->
+ * <lib-user-select
+ *   [(value)]="selectedUserId"
+ *   [isEditMode]="true"
  * />
- * ```
- */
-declare class FileUploaderComponent {
-    private readonly messageService;
-    readonly uploadFile: _angular_core.InputSignal<UploadFileFn>;
-    readonly acceptTypes: _angular_core.InputSignal<string[]>;
-    readonly multiple: _angular_core.InputSignal<boolean>;
-    readonly maxFiles: _angular_core.InputSignal<number>;
-    readonly maxSizeMb: _angular_core.InputSignal<number>;
-    readonly uploadOptions: _angular_core.InputSignal<IFileUploadOptions>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly showPreview: _angular_core.InputSignal<boolean>;
-    readonly autoUpload: _angular_core.InputSignal<boolean>;
-    readonly fileUploaded: _angular_core.OutputEmitterRef<IUploadedFile>;
-    readonly filesUploaded: _angular_core.OutputEmitterRef<IUploadedFile[]>;
-    readonly onError: _angular_core.OutputEmitterRef<Error>;
-    readonly fileSelected: _angular_core.OutputEmitterRef<File[]>;
-    readonly isUploading: _angular_core.WritableSignal<boolean>;
-    readonly isDragOver: _angular_core.WritableSignal<boolean>;
-    readonly uploadProgress: _angular_core.WritableSignal<number>;
-    readonly uploadingFileName: _angular_core.WritableSignal<string>;
-    readonly selectedFiles: _angular_core.WritableSignal<File[]>;
-    readonly acceptString: _angular_core.Signal<string>;
-    readonly acceptTypesDisplay: _angular_core.Signal<string>;
-    onDragOver(event: DragEvent): void;
-    onDragLeave(event: DragEvent): void;
-    onDrop(event: DragEvent): void;
-    onFileSelected(event: Event): void;
-    private handleFiles;
-    removeFile(file: File): void;
-    uploadFiles(files?: File[]): Promise<void>;
-    getFileIcon(file: File): string;
-    formatSize(bytes: number): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploaderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploaderComponent, "lib-file-uploader", never, { "uploadFile": { "alias": "uploadFile"; "required": true; "isSignal": true; }; "acceptTypes": { "alias": "acceptTypes"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "maxSizeMb": { "alias": "maxSizeMb"; "required": false; "isSignal": true; }; "uploadOptions": { "alias": "uploadOptions"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showPreview": { "alias": "showPreview"; "required": false; "isSignal": true; }; "autoUpload": { "alias": "autoUpload"; "required": false; "isSignal": true; }; }, { "fileUploaded": "fileUploaded"; "filesUploaded": "filesUploaded"; "onError": "onError"; "fileSelected": "fileSelected"; }, never, never, true, never>;
-}
-
-/**
- * File Selector Dialog - Browse and select existing files with filtering.
- *
- * Pass your own `loadFiles` function - works with any storage API.
- *
- * Features:
- * - Search with debouncing
- * - File type filtering
- * - Infinite scroll pagination
- * - Single or multiple selection
- * - File preview with icons
- *
- * @example
- * ```typescript
- * // In component
- * readonly fileService = inject(FileManagerApiService);
- *
- * readonly loadFiles: LoadFilesFn = (filter) =>
- *   this.fileService.getAll(filter.search, {
- *     pagination: { currentPage: filter.page, pageSize: filter.pageSize },
- *     filter: { contentTypes: filter.contentTypes },
- *   }).pipe(
- *     map(res => ({
- *       ...res,
- *       data: res.data?.map(f => ({
- *         id: f.id,
- *         name: f.name,
- *         contentType: f.contentType,
- *         size: f.size,
- *         url: f.url
- *       }))
- *     }))
- *   );
- * ```
  *
- * ```html
- * <lib-file-selector-dialog
- *   [(visible)]="showFileSelector"
- *   [loadFiles]="loadFiles"
- *   [acceptTypes]="['image/*']"
- *   [multiple]="false"
- *   (fileSelected)="onFileSelected($event)"
+ * <!-- With custom loadUsers function -->
+ * <lib-user-select
+ *   [(value)]="selectedUserId"
+ *   [isEditMode]="true"
+ *   [loadUsers]="customLoadUsers"
  * />
  * ```
  */
-declare class FileSelectorDialogComponent {
-    private readonly destroyRef;
-    private abortController;
-    private searchDebounceTimer;
-    readonly loadFiles: _angular_core.InputSignal<LoadFilesFn>;
-    readonly header: _angular_core.InputSignal<string>;
-    readonly acceptTypes: _angular_core.InputSignal<string[]>;
-    readonly multiple: _angular_core.InputSignal<boolean>;
-    readonly maxSelection: _angular_core.InputSignal<number>;
-    readonly pageSize: _angular_core.InputSignal<number>;
-    readonly visible: _angular_core.ModelSignal<boolean>;
-    readonly fileSelected: _angular_core.OutputEmitterRef<IFileBasicInfo>;
-    readonly filesSelected: _angular_core.OutputEmitterRef<IFileBasicInfo[]>;
-    readonly closed: _angular_core.OutputEmitterRef<void>;
-    readonly onError: _angular_core.OutputEmitterRef<Error>;
-    readonly isLoading: _angular_core.WritableSignal<boolean>;
-    readonly files: _angular_core.WritableSignal<IFileBasicInfo[]>;
-    readonly selectedFiles: _angular_core.WritableSignal<IFileBasicInfo[]>;
-    readonly total: _angular_core.WritableSignal<number | undefined>;
-    readonly pagination: _angular_core.WritableSignal<IPagination>;
-    readonly searchTerm: _angular_core.WritableSignal<string>;
-    readonly acceptString: _angular_core.Signal<string>;
-    constructor();
-    onSearchChange(value: string): void;
-    onScroll(event: Event): void;
-    toggleSelection(file: IFileBasicInfo): void;
-    isSelected(file: IFileBasicInfo): boolean;
-    isFileAllowed(file: IFileBasicInfo): boolean;
-    isImage(file: IFileBasicInfo): boolean;
-    getFileIcon(file: IFileBasicInfo): string;
-    formatSize(size: string): string;
-    onCancel(): void;
-    onConfirm(): void;
-    onDialogHide(): void;
-    private resetState;
-    private fetchFiles;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileSelectorDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileSelectorDialogComponent, "lib-file-selector-dialog", never, { "loadFiles": { "alias": "loadFiles"; "required": true; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "acceptTypes": { "alias": "acceptTypes"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxSelection": { "alias": "maxSelection"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "fileSelected": "fileSelected"; "filesSelected": "filesSelected"; "closed": "closed"; "onError": "onError"; }, never, never, true, never>;
+declare class UserSelectComponent extends BaseUserSelectComponent {
+    readonly showClear: _angular_core.InputSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly userSelected: _angular_core.OutputEmitterRef<IUserBasicInfo | null>;
+    protected setupValueEffect(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserSelectComponent, "lib-user-select", never, { "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "userSelected": "userSelected"; }, never, never, true, never>;
 }
 
 /**
@@ -1716,86 +1545,66 @@ declare const AUTH_STATE_PROVIDER: InjectionToken<IAuthStateProvider>;
  */
 declare const PROFILE_PERMISSION_PROVIDER: InjectionToken<IProfilePermissionProvider>;
 /**
- * Profile Upload Provider Token
- *
- * Provides file upload functionality for profile pictures.
- * Optional - if not configured or storage not enabled, upload section is hidden.
- * Use with `inject(PROFILE_UPLOAD_PROVIDER, { optional: true })`.
- */
-declare const PROFILE_UPLOAD_PROVIDER: InjectionToken<IProfileUploadProvider>;
-/**
- * User List Provider Token
+ * File Provider Token
  *
- * Provides extra actions, columns, and data enrichment for user list.
- * Optional - if not configured, default user list behavior is used.
- * Use with `inject(USER_LIST_PROVIDER, { optional: true })`.
+ * Provides file loading and upload functionality for file selectors.
+ * Optional - if not configured, file selector requires loadFiles/uploadFile inputs.
+ * Use with `inject(FILE_PROVIDER, { optional: true })`.
  *
  * @example
  * // In app.config.ts
  * providers: [
- *   { provide: USER_LIST_PROVIDER, useClass: MyUserListProvider },
+ *   { provide: FILE_PROVIDER, useClass: StorageFileProvider },
  * ]
  */
-declare const USER_LIST_PROVIDER: InjectionToken<IUserListProvider<IUserListItem>>;
+declare const FILE_PROVIDER: InjectionToken<IFileProvider>;
 
 /**
- * Permission Guard
- *
- * Route-level guard for permission-based access control.
- * Validates permissions before allowing navigation.
- *
- * Features:
- * - Single permission check
- * - Complex ILogicNode logic trees
- * - Configurable redirect URL
- * - Debug logging for denied access
+ * Permission Guard - Single permission or ILogicNode check.
  *
  * @example
  * ```typescript
- * // Simple permission check
  * { path: 'users', canActivate: [permissionGuard('user.view')] }
- *
- * // Complex logic
- * { path: 'admin', canActivate: [permissionGuard({
- *   id: 'root',
- *   type: 'group',
- *   operator: 'AND',
- *   children: [
- *     { id: '1', type: 'action', actionId: 'admin.view' },
- *     { id: '2', type: 'action', actionId: 'admin.manage' }
- *   ]
- * })] }
- *
- * // With custom redirect
- * { path: 'users', canActivate: [permissionGuard('user.view', '/access-denied')] }
+ * { path: 'admin', canActivate: [permissionGuard(logicNode, '/access-denied')] }
  * ```
  */
 declare function permissionGuard(permission: string | ILogicNode, redirectTo?: string): CanActivateFn;
 /**
- * Any Permission Guard (OR logic)
- *
- * Allows access if user has ANY of the specified permissions.
+ * Any Permission Guard (OR logic) - Access if user has ANY permission.
  *
  * @example
  * ```typescript
- * // Allow if user has view OR create permission
  * { path: 'users', canActivate: [anyPermissionGuard(['user.view', 'user.create'])] }
  * ```
  */
 declare function anyPermissionGuard(permissions: string[], redirectTo?: string): CanActivateFn;
 /**
- * All Permissions Guard (AND logic)
- *
- * Allows access only if user has ALL of the specified permissions.
+ * All Permissions Guard (AND logic) - Access only if user has ALL permissions.
  *
  * @example
  * ```typescript
- * // Allow only if user has BOTH view AND create permissions
  * { path: 'admin', canActivate: [allPermissionsGuard(['admin.view', 'admin.manage'])] }
  * ```
  */
 declare function allPermissionsGuard(permissions: string[], redirectTo?: string): CanActivateFn;
 
+declare function localToUtc(dateStr: string, timeStr: string, timezone: string): Date;
+declare function utcToLocal(utcDate: Date | string, timezone: string): {
+    date: string;
+    time: string;
+    display: string;
+};
+declare function formatInTimezone(utcDate: Date | string, timezone: string, options?: Intl.DateTimeFormatOptions): string;
+declare function getUserTimezone(): string;
+
+/**
+ * Check if user has a specific permission using wildcard matching.
+ * Supports:
+ * - Exact match: 'user.create' matches 'user.create'
+ * - Full wildcard: '*' matches everything
+ * - Module wildcard: 'user.*' matches 'user.create', 'user.read', etc.
+ */
+declare function hasPermission(requiredPermission: string, userPermissions: string[]): boolean;
 /** Evaluate permission logic (string or ILogicNode) against user permissions */
 declare function evaluatePermission(logic: string | ILogicNode | null | undefined, permissions: string[]): boolean;
 /** Recursively evaluate an ILogicNode tree */
@@ -1805,5 +1614,38 @@ declare function hasAnyPermission(permissionCodes: string[], permissions: string
 /** Check if user has ALL of the specified permissions (AND logic) */
 declare function hasAllPermissions(permissionCodes: string[], permissions: string[]): boolean;
 
-export { AUTH_STATE_PROVIDER, AngularModule, ApiResourceService, ApiResourceService as ApiService, COMPANY_API_PROVIDER, ContactTypeEnum, CookieService, EditModeElementChangerDirective, FILE_TYPE_FILTERS, FileSelectorDialogComponent, FileUploaderComponent, FileUrlService, HasPermissionDirective, IconComponent, IconTypeEnum, IsEmptyImageDirective, LazyMultiSelectComponent, LazySelectComponent, PROFILE_PERMISSION_PROVIDER, PROFILE_UPLOAD_PROVIDER, PermissionValidatorService, PlatformService, PreventDefaultDirective, PrimeModule, USER_LIST_PROVIDER, USER_PERMISSION_PROVIDER, USER_PROVIDER, UserMultiSelectComponent, UserSelectComponent, allPermissionsGuard, anyPermissionGuard, evaluateLogicNode, evaluatePermission, formatFileSize, getAcceptString, getFileIconClass, hasAllPermissions, hasAnyPermission, isFileTypeAllowed, permissionGuard };
-export type { ApiResponse, DeleteType, FilesResponseDto, GetFileUrlsFn, GetFilesRequestDto, IActionNode, IActivatable, IApiService, IAuthStateProvider, IBaseEntity, IBulkMeta, IBulkResponse, ICompanyApiProvider, ICompanyBasicInfo, IDeleteData, IDropDown, IErrorResponse, IFileBasicInfo, IFileData, IFileSelectFilter, IFileUploadOptions, IFilter, IFilterData, IGroupNode, IListResponse, ILoggedUserInfo, ILogicNode, ILoginResponse, ILoginUserData, IMessageResponse, IMetadata, IOrderable, IPagination, IPaginationMeta, IProfileActionInfo, IProfilePermissionProvider, IProfileRoleInfo, IProfileUploadOptions, IProfileUploadProvider, IProfileUploadResult, IRefreshTokenResponse, IRequestMeta, ISingleResponse, ISoftDeletable, ISort, ITimestampable, IUploadedFile, IUserBasicInfo, IUserBranchPayload, IUserCompanyPayload, IUserListAction, IUserListColumn, IUserListFilter, IUserListItem, IUserListProvider, IUserPermissionProvider, IUserProvider, IUserSelectFilter, IValidationError, LoadFilesFn, LoadUsersFn, UploadFileFn };
+/**
+ * Configuration for scroll pagination behavior
+ */
+interface ScrollPaginationConfig {
+    /** Distance from bottom to trigger pagination (default: 50px) */
+    threshold?: number;
+    /** Current pagination state */
+    pagination: IPagination;
+    /** Total items available */
+    total: number | undefined;
+    /** Whether currently loading */
+    isLoading: boolean;
+}
+/**
+ * Check if scroll has reached near bottom and calculate next page if available.
+ * Returns next pagination if should load more, null otherwise.
+ *
+ * @example
+ * ```typescript
+ * onScroll(event: Event): void {
+ *   const nextPagination = checkScrollPagination(event, {
+ *     pagination: this.pagination(),
+ *     total: this.total(),
+ *     isLoading: this.isLoading(),
+ *   });
+ *   if (nextPagination) {
+ *     this.onPagination.emit(nextPagination);
+ *   }
+ * }
+ * ```
+ */
+declare function checkScrollPagination(event: Event, config: ScrollPaginationConfig): IPagination | null;
+
+export { ACTION_PERMISSIONS, AUTH_STATE_PROVIDER, AngularModule, ApiResourceService, ApiResourceService as ApiService, BRANCH_PERMISSIONS, BaseFormComponent, BaseFormControl, BaseFormTemplateDirective, BaseListComponent, BaseListTemplateDirective, BaseUserSelectComponent, COMPANY_ACTION_PERMISSIONS, COMPANY_API_PROVIDER, COMPANY_PERMISSIONS, CookieService, EMAIL_CONFIG_PERMISSIONS, EMAIL_TEMPLATE_PERMISSIONS, EVENT_PERMISSIONS, EditModeElementChangerDirective, FILE_PERMISSIONS, FILE_PROVIDER, FILE_TYPE_FILTERS, FOLDER_PERMISSIONS, FORM_PERMISSIONS, FORM_RESULT_PERMISSIONS, FaviconService, FileSelectorDialogComponent, FileUploaderComponent, FileUrlService, HasPermissionDirective, IconComponent, IconTypeEnum, InlineSvgComponent, IsEmptyImageDirective, LANGUAGE_PERMISSIONS, LazyMultiSelectComponent, LazySelectComponent, NOTIFICATION_PERMISSIONS, PERMISSIONS, PROFILE_PERMISSION_PROVIDER, PermissionValidatorService, PlatformService, PreventDefaultDirective, ROLE_ACTION_PERMISSIONS, ROLE_PERMISSIONS, RouterTabsComponent, SHARED_MESSAGES, SKIP_ERROR_TOAST, STORAGE_CONFIG_PERMISSIONS, TRANSLATION_KEY_PERMISSIONS, TRANSLATION_PERMISSIONS, TranslatePipe, TranslateService, UPLOAD_CONFIG_PERMISSIONS, USER_ACTION_PERMISSIONS, USER_PERMISSIONS, USER_PERMISSION_PROVIDER, USER_PROVIDER, USER_ROLE_PERMISSIONS, UserMultiSelectComponent, UserSelectComponent, allPermissionsGuard, anyPermissionGuard, checkScrollPagination, errorCatchingInterceptor, evaluateLogicNode, evaluatePermission, formatFileSize, formatInTimezone, getAcceptString, getFileIconClass, getUserTimezone, hasAllPermissions, hasAnyPermission, hasPermission, isFileTypeAllowed, localToUtc, permissionGuard, provideValueAccessor, resolveTranslationModule, utcToLocal };
+export type { ActionSeverity, DeleteType, FilesResponseDto, FormFieldType, IActionNode, IActivatable, IApiService, IAuthStateProvider, IBaseEntity, IBulkMeta, IBulkResponse, ICompanyApiProvider, ICompanyBasicInfo, IDeleteData, IDropDown, IFileBasicInfo, IFileProvider, IFileSelectFilter, IFileUploadOptions, IFilter, IFilterData, IFolderBasicInfo, IFormField, IFormSelectOption, IGroupNode, IListResponse, ILoggedUserInfo, ILogicNode, IMessageResponse, IOrderable, IPagination, IPaginationMeta, IProfileActionInfo, IProfilePermissionProvider, IProfileRoleInfo, IRequestMeta, IResolverModuleConfig, ISelectFilter, ISingleResponse, ISoftDeletable, ISort, IStorageConfigBasicInfo, ITableAction, ITableColumn, ITagConfig, ITimestampable, IUploadedFile, IUserBasicInfo, IUserBranchPermission, IUserPermissionProvider, IUserProvider, IUserSelectFilter, LoadUsersFn, PermissionCode, RouterTabItem, ScrollPaginationConfig, TableColumnType, UploadFileFn, UploadMultipleFilesFn };