@flusys/ng-shared 0.1.0-alpha.1

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

@@ -0,0 +1,1107 @@
+import { Observable } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, ResourceRef, Injector, model, ElementRef, InjectionToken } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i2 from '@angular/router';
+import { CanActivateFn } from '@angular/router';
+import * as i5 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1$1 from 'primeng/inputtext';
+import * as i2$1 from 'primeng/tag';
+import * as i3 from 'primeng/selectbutton';
+import * as i4 from 'primeng/password';
+import * as i5$1 from 'primeng/button';
+import * as i6 from 'primeng/tooltip';
+import * as i7 from 'primeng/checkbox';
+import { CheckboxChangeEvent } from 'primeng/checkbox';
+import * as i8 from 'primeng/steps';
+import * as i9 from 'primeng/ripple';
+import * as i10 from 'primeng/panel';
+import * as i11 from 'primeng/paginator';
+import * as i12 from 'primeng/table';
+import * as i13 from 'primeng/inputnumber';
+import * as i14 from 'primeng/textarea';
+import * as i15 from 'primeng/progressbar';
+import * as i16 from 'primeng/fileupload';
+import * as i17 from 'primeng/card';
+import * as i18 from 'primeng/select';
+import * as i19 from 'primeng/inputicon';
+import * as i20 from 'primeng/iconfield';
+import * as i21 from 'primeng/popover';
+import * as i22 from 'primeng/listbox';
+import * as i23 from 'primeng/radiobutton';
+import * as i24 from 'primeng/toggleswitch';
+import * as i25 from 'primeng/image';
+import * as i26 from 'primeng/datepicker';
+import * as i27 from 'primeng/splitbutton';
+import * as i28 from 'primeng/divider';
+import * as i29 from 'primeng/multiselect';
+import * as i30 from 'primeng/autocomplete';
+import * as i31 from 'primeng/tabs';
+import * as i32 from 'primeng/dialog';
+import * as i33 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 { FormValueControl } from '@angular/forms/signals';
+
+/**
+ * Base entity interface - matches backend Identity entity
+ */
+interface IBaseEntity {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt?: Date | null;
+    createdById?: string | null;
+    updatedById?: string | null;
+    deletedById?: string | null;
+}
+/**
+ * Soft deletable entity mixin
+ */
+interface ISoftDeletable {
+    deletedAt?: Date | null;
+}
+/**
+ * Timestampable entity mixin
+ */
+interface ITimestampable {
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Entity with active status
+ */
+interface IActivatable {
+    isActive: boolean;
+}
+/**
+ * Entity with ordering/serial
+ */
+interface IOrderable {
+    serial?: number | null;
+}
+/**
+ * Entity with metadata JSON field
+ */
+interface IMetadata {
+    metadata?: Record<string, unknown> | null;
+}
+/**
+ * Logged-in user info - matches backend ILoggedUserInfo
+ */
+interface ILoggedUserInfo {
+    id: string;
+    email: string;
+    name?: string;
+    phone?: string;
+    profilePictureId?: string;
+    companyId?: string;
+    branchId?: string;
+    companyLogoId?: string;
+    branchLogoId?: string;
+}
+
+/**
+ * Request metadata added by backend ResponseMetaInterceptor
+ */
+interface IRequestMeta {
+    requestId?: string;
+    timestamp?: string;
+    responseTime?: number;
+}
+/**
+ * Pagination metadata for list responses
+ */
+interface IPaginationMeta {
+    total: number;
+    page: number;
+    pageSize: number;
+    count: number;
+    hasMore?: boolean;
+    totalPages?: number;
+}
+/**
+ * Bulk operation metadata
+ */
+interface IBulkMeta {
+    count: number;
+    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;
+    data?: T;
+    _meta?: IRequestMeta;
+}
+/**
+ * List response with pagination (get-all)
+ */
+interface IListResponse<T> {
+    success: boolean;
+    message: string;
+    data?: T[];
+    meta: IPaginationMeta;
+    _meta?: IRequestMeta;
+}
+/**
+ * Bulk operation response (insert-many, update-many)
+ */
+interface IBulkResponse<T> {
+    success: boolean;
+    message: string;
+    data?: T[];
+    meta: IBulkMeta;
+    _meta?: IRequestMeta;
+}
+/**
+ * Message-only response (delete, logout, status updates)
+ */
+interface IMessageResponse {
+    success: boolean;
+    message: string;
+    _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 {
+    id: string;
+    name: string;
+    slug: string;
+    logoId?: string;
+}
+interface IUserBranchPayload {
+    id: string;
+    name: string;
+    slug: string;
+    logoId?: string;
+}
+interface ILoginUserData {
+    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;
+}
+interface IFileData {
+    id: string;
+    name: string;
+    originalName: string;
+    contentType: string;
+    size: number;
+    key: string;
+    url?: string;
+    thumbnailUrl?: string;
+    createdAt: Date;
+}
+
+/**
+ * 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>>;
+}
+
+/**
+ * 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 IDropDown {
+    label: string;
+    value: string;
+}
+
+interface IPagination {
+    pageSize: number;
+    currentPage: number;
+}
+interface ISort {
+    [key: string]: 'ASC' | 'DESC';
+}
+interface IFilter {
+    [key: string]: any;
+}
+interface IFilterData {
+    filter?: IFilter;
+    pagination?: IPagination;
+    select?: string[];
+    sort?: ISort;
+    withDeleted?: boolean;
+    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);
+ *
+ *   async loadUserBranches(userId: string) {
+ *     const response = await this.userPermissionProvider
+ *       .getUserBranchPermissions(userId, '')
+ *       .toPromise();
+ *     this.branches.set(response?.data ?? []);
+ *   }
+ * }
+ */
+interface IUserPermissionProvider {
+    /**
+     * Get user's branch permissions
+     */
+    getUserBranchPermissions(userId: string): Observable<ISingleResponse<any>>;
+}
+
+/**
+ * User data for dropdowns and selectors
+ */
+interface IUserBasicInfo {
+    id: string;
+    name: string;
+    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);
+ *     });
+ *   }
+ * }
+ */
+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;
+    }): Observable<IListResponse<IUserBasicInfo>>;
+}
+
+declare enum ContactTypeEnum {
+    PHONE = 1,
+    EMAIL = 2
+}
+
+declare enum IconTypeEnum {
+    PRIMENG_ICON = 1,
+    IMAGE_FILE_LINK = 2,
+    DIRECT_TAG_SVG = 3
+}
+
+declare class CookieService {
+    private doc;
+    private platformService;
+    private readonly request;
+    get(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CookieService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CookieService>;
+}
+
+/**
+ * Request DTO for fetching file URLs
+ */
+interface GetFilesRequestDto {
+    id: string;
+}
+/**
+ * Response DTO with file information including URL
+ */
+interface FilesResponseDto {
+    id: string;
+    name: string;
+    contentType: string;
+    url: string;
+}
+/**
+ * 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)
+ */
+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.
+     * Returns Observable of fetched files.
+     */
+    fetchFileUrls(fileIds: string[]): Observable<FilesResponseDto[]>;
+    /**
+     * Fetch a single file URL.
+     * Returns Observable of file info or null if not found.
+     */
+    fetchSingleFileUrl(fileId: string): 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;
+    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
+ */
+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
+     */
+    setPermissions(permissions: string[]): void;
+    /**
+     * 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
+     */
+    isPermissionsLoaded(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PermissionValidatorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PermissionValidatorService>;
+}
+
+declare class PlatformService {
+    private readonly platformId;
+    get isServer(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlatformService>;
+}
+
+declare class EditModeElementChangerDirective implements AfterViewInit {
+    private el;
+    private ngControl;
+    readonly isEditMode: _angular_core.InputSignal<boolean>;
+    constructor();
+    ngAfterViewInit(): void;
+    private updateControl;
+    private updateElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditModeElementChangerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EditModeElementChangerDirective, "[appEditModeElementChanger]", never, { "isEditMode": { "alias": "isEditMode"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * HasPermission Directive
+ *
+ * Structural directive for permission-based rendering.
+ * Shows/hides elements based on permission logic evaluation.
+ *
+ * Supports:
+ * - Simple permission check (string)
+ * - Complex permission logic (ILogicNode with AND/OR operators)
+ *
+ * Usage:
+ * ```html
+ * <!-- Simple permission check -->
+ * <button *hasPermission="'user.create'">Create User</button>
+ *
+ * <!-- Complex permission logic -->
+ * <button *hasPermission="userManageLogic">Manage Users</button>
+ *
+ * <!-- Where userManageLogic is: -->
+ * <!-- (user.view OR user.create) AND department.manage -->
+ * ```
+ *
+ * The directive automatically reacts to permission changes through signals.
+ *
+ * @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' }
+ *       ]
+ *     },
+ *     { id: '4', type: 'action', actionId: 'department.manage' }
+ *   ]
+ * };
+ *
+ * // In template
+ * <div *hasPermission="userManageLogic">
+ *   User management content
+ * </div>
+ */
+declare class HasPermissionDirective {
+    private readonly templateRef;
+    private readonly viewContainer;
+    private readonly permissionValidator;
+    /**
+     * Permission logic input signal
+     * Accepts either:
+     * - string: Single permission code to check
+     * - ILogicNode: Complex permission logic tree
+     */
+    readonly hasPermission: _angular_core.InputSignal<string | ILogicNode | null>;
+    /**
+     * View created state
+     */
+    private viewCreated;
+    constructor();
+    /**
+     * Update view based on permission evaluation
+     */
+    private updateView;
+    /**
+     * Clear the view container
+     */
+    private clearView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HasPermissionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HasPermissionDirective, "[hasPermission]", never, { "hasPermission": { "alias": "hasPermission"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IsEmptyImageDirective {
+    readonly src: _angular_core.InputSignal<string>;
+    private readonly hasError;
+    private readonly defaultImg;
+    readonly imageSrc: _angular_core.Signal<string>;
+    onError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsEmptyImageDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IsEmptyImageDirective, "img", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PreventDefaultDirective {
+    eventType: _angular_core.InputSignal<"click" | "keydown" | "keyup">;
+    preventKey: _angular_core.InputSignal<string | undefined>;
+    action: _angular_core.OutputEmitterRef<Event>;
+    onClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    onKeyup(event: KeyboardEvent): void;
+    private processEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PreventDefaultDirective, never>;
+    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.RouterOutlet, typeof i2.RouterLink, typeof IsEmptyImageDirective, typeof i1.NgOptimizedImage, typeof i1.NgComponentOutlet, typeof PreventDefaultDirective], [typeof i1.CommonModule, typeof i5.ReactiveFormsModule, typeof i5.FormsModule, typeof i2.RouterOutlet, typeof i2.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.InputTextModule, typeof i2$1.TagModule, typeof i3.SelectButtonModule, typeof i4.PasswordModule, typeof i5$1.ButtonModule, typeof i6.TooltipModule, typeof i7.CheckboxModule, typeof i8.StepsModule, typeof i9.RippleModule, typeof i10.PanelModule, typeof i11.PaginatorModule, typeof i12.TableModule, typeof i13.InputNumberModule, typeof i14.TextareaModule, typeof i15.ProgressBarModule, typeof i16.FileUploadModule, typeof i17.CardModule, typeof i18.SelectModule, typeof i19.InputIconModule, typeof i20.IconFieldModule, typeof i21.PopoverModule, typeof i22.ListboxModule, typeof i23.RadioButtonModule, typeof i24.ToggleSwitchModule, typeof i25.ImageModule, typeof i26.DatePickerModule, typeof i27.SplitButtonModule, typeof i28.DividerModule, typeof i29.MultiSelectModule, typeof i30.AutoCompleteModule, typeof i31.TabsModule, typeof i32.DialogModule, typeof i33.TreeTableModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<PrimeModule>;
+}
+
+/**
+ * Service interface for CRUD operations.
+ * Matches NestJS shared API controller endpoints:
+ *
+ * | 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       |
+ */
+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>;
+}
+/**
+ * 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.
+ *
+ * ## Endpoint Mapping
+ *
+ * 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
+ *
+ * @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' });
+ * ```
+ */
+declare abstract class ApiResourceService<DtoT, InterfaceT> implements IApiService<DtoT, InterfaceT> {
+    protected readonly baseUrl: string;
+    protected readonly loaderService: ApiLoaderService;
+    protected readonly http: HttpClient;
+    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 - uses IListResponse matching backend */
+    readonly listResource: ResourceRef<IListResponse<InterfaceT> | undefined>;
+    /** Whether data is currently loading */
+    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);
+    protected getHttpOptions(endpoint: string, params?: HttpParams): {
+        params?: HttpParams | undefined;
+        headers: HttpHeaders;
+    };
+    /**
+     * Fetch list data (triggers resource reload)
+     */
+    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;
+    /**
+     * 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)
+     */
+    deleteAsync(deleteDto: IDeleteData): Promise<IMessageResponse>;
+}
+
+declare class IconComponent {
+    icon: _angular_core.InputSignal<string>;
+    iconType: _angular_core.InputSignal<IconTypeEnum | undefined>;
+    protected readonly IconTypeEnum: typeof IconTypeEnum;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
+    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>;
+}
+
+/**
+ * Lazy-loading multi-select component with search, pagination, and select-all.
+ *
+ * Supports ALL Angular form patterns:
+ * - Template-driven: `[(value)]="selectedIds"`
+ * - Reactive forms: `[formControl]="ctrl"` or `formControlName="field"`
+ * - Signal forms: `[formField]="formTree.field"`
+ */
+declare class LazyMultiSelectComponent extends BaseFormControl<string[] | null> {
+    readonly placeHolder: _angular_core.InputSignal<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 selectedValueDisplay: _angular_core.Signal<string>;
+    /** Computed: Whether all items are selected (replaces isSelectAll signal) */
+    readonly isSelectAll: _angular_core.Signal<boolean>;
+    constructor();
+    scrollTargetEl: HTMLElement | null;
+    private readonly onScrollBound;
+    readonly multiScrollContainer: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    onScroll(event: Event): void;
+    readonly pSelectRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    openOptions: _angular_core.WritableSignal<boolean>;
+    onSelectClick(event: Event): void;
+    onOverlayClick(event: Event): void;
+    handleDocumentClick(event: MouseEvent): void;
+    isSelected(data: IDropDown): boolean | undefined;
+    key(option: IDropDown): string;
+    selectValue(event: CheckboxChangeEvent, option: IDropDown): void;
+    changeSelectAll(event: CheckboxChangeEvent): void;
+    clear(event: Event): void;
+    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>;
+}
+
+/**
+ * Lazy-loading single select component with search and pagination.
+ *
+ * Supports ALL Angular form patterns:
+ * - Template-driven: `[(value)]="selectedId"`
+ * - Reactive forms: `[formControl]="ctrl"` or `formControlName="field"`
+ * - Signal forms: `[formField]="formTree.field"`
+ */
+declare class LazySelectComponent extends BaseFormControl<string | null> {
+    readonly placeHolder: _angular_core.InputSignal<string>;
+    readonly optionLabel: _angular_core.InputSignal<string>;
+    readonly optionValue: _angular_core.InputSignal<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>;
+    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;
+    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>;
+}
+
+/**
+ * Injection Tokens for Provider Interfaces
+ *
+ * These tokens enable dependency injection of provider implementations
+ * without creating direct package dependencies.
+ *
+ * Pattern:
+ * 1. ng-shared defines interfaces and tokens (no implementation)
+ * 2. ng-auth provides implementations
+ * 3. ng-iam and ng-storage inject via tokens
+ * 4. app.config.ts wires everything together
+ *
+ * @example
+ * // In IAM component
+ * private readonly userProvider = inject(USER_PROVIDER);
+ *
+ * // In app.config.ts
+ * providers: [
+ *   { provide: USER_PROVIDER, useClass: AuthUserProvider },
+ * ]
+ */
+/**
+ * User Provider Token
+ *
+ * Provides user data access for IAM user selection.
+ */
+declare const USER_PROVIDER: InjectionToken<IUserProvider>;
+/**
+ * Company API Provider Token
+ *
+ * Provides company data access for IAM company selection.
+ */
+declare const COMPANY_API_PROVIDER: InjectionToken<ICompanyApiProvider>;
+/**
+ * User Permission Provider Token
+ *
+ * Provides user permission assignment operations for IAM.
+ */
+declare const USER_PERMISSION_PROVIDER: InjectionToken<IUserPermissionProvider>;
+
+/**
+ * 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
+ *
+ * @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')] }
+ * ```
+ */
+declare function permissionGuard(permission: string | ILogicNode, redirectTo?: string): CanActivateFn;
+/**
+ * Any Permission Guard (OR logic)
+ *
+ * Allows access if user has ANY of the specified permissions.
+ *
+ * @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.
+ *
+ * @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;
+
+/** 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 */
+declare function evaluateLogicNode(node: ILogicNode, permissions: string[]): boolean;
+/** Check if user has ANY of the specified permissions (OR logic) */
+declare function hasAnyPermission(permissionCodes: string[], permissions: string[]): boolean;
+/** Check if user has ALL of the specified permissions (AND logic) */
+declare function hasAllPermissions(permissionCodes: string[], permissions: string[]): boolean;
+
+export { AngularModule, ApiResourceService, ApiResourceService as ApiService, COMPANY_API_PROVIDER, ContactTypeEnum, CookieService, EditModeElementChangerDirective, FileUrlService, HasPermissionDirective, IconComponent, IconTypeEnum, IsEmptyImageDirective, LazyMultiSelectComponent, LazySelectComponent, PermissionValidatorService, PlatformService, PreventDefaultDirective, PrimeModule, USER_PERMISSION_PROVIDER, USER_PROVIDER, allPermissionsGuard, anyPermissionGuard, evaluateLogicNode, evaluatePermission, hasAllPermissions, hasAnyPermission, permissionGuard };
+export type { ApiResponse, DeleteType, FilesResponseDto, GetFilesRequestDto, IActionNode, IActivatable, IApiService, IBaseEntity, IBulkMeta, IBulkResponse, ICompanyApiProvider, ICompanyBasicInfo, IDeleteData, IDropDown, IErrorResponse, IFileData, IFilter, IFilterData, IGroupNode, IListResponse, ILoggedUserInfo, ILogicNode, ILoginResponse, ILoginUserData, IMessageResponse, IMetadata, IOrderable, IPagination, IPaginationMeta, IRefreshTokenResponse, IRequestMeta, ISingleResponse, ISoftDeletable, ISort, ITimestampable, IUserBasicInfo, IUserBranchPayload, IUserCompanyPayload, IUserPermissionProvider, IUserProvider, IValidationError };