@codex-ts/core-lib 1.0.9 → 1.0.13

package/fesm2022/codex-ts-core-lib.mjs

@@ -1,17 +1,17 @@
 import * as i0 from '@angular/core';
-import { Injectable, Directive, Input, Component, ViewChild, Pipe, NgModule } from '@angular/core';
-import { BehaviorSubject, finalize, Observable, forkJoin, throwError, map, take, of, isObservable } from 'rxjs';
-import * as i1 from 'primeng/api';
-import * as i1$1 from '@angular/common/http';
+import { InjectionToken, Inject, Injectable, Component, NgModule, Directive, Input, ViewChild, Pipe } from '@angular/core';
+import { map, retry, timeout, catchError, take, finalize as finalize$1, switchMap, takeUntil, mergeMap, tap, debounceTime, distinctUntilChanged } from 'rxjs/operators';
+import { BehaviorSubject, finalize, Observable, forkJoin, throwError, of, isObservable, Subject, take as take$1, tap as tap$1, map as map$1, catchError as catchError$1, takeUntil as takeUntil$1, ReplaySubject, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
+import * as i1 from '@angular/common/http';
 import { HttpParams } from '@angular/common/http';
-import { retry, timeout, catchError, finalize as finalize$1 } from 'rxjs/operators';
-import * as i1$4 from '@angular/forms';
+import * as i1$1 from '@angular/router';
+import * as i2 from 'primeng/api';
+import * as i1$2 from '@angular/forms';
 import { FormGroup, ReactiveFormsModule } from '@angular/forms';
-import * as i1$2 from '@angular/router';
+import * as i2$1 from '@ngx-formly/core';
+import { FieldType, FormlyModule, FieldWrapper } from '@ngx-formly/core';
 import * as i1$3 from '@angular/common';
 import { CommonModule, formatDate } from '@angular/common';
-import * as i2 from '@ngx-formly/core';
-import { FieldType, FormlyModule, FieldWrapper } from '@ngx-formly/core';
 import * as i3 from 'primeng/inputtext';
 import { InputTextModule } from 'primeng/inputtext';
 import * as i4 from 'primeng/select';
@@ -28,300 +28,269 @@ import * as i3$3 from 'primeng/checkbox';
 import { CheckboxModule } from 'primeng/checkbox';
 import * as i3$4 from 'primeng/inputtextarea';
 import { Textarea } from 'primeng/inputtextarea';
-import * as i2$1 from 'primeng/tooltip';
+import * as i2$2 from 'primeng/tooltip';
 import { TooltipModule } from 'primeng/tooltip';
 
+class AppConstants {
+    static FORM = {
+        MODE: 'mode',
+        UUID: 'uuid',
+        NEW: 'new'
+    };
+    static PAGE_MODE = {
+        CREATE: 'create',
+        EDIT: 'edit',
+        VIEW: 'view'
+    };
+}
+
+const AppMessages = {
+    COMMON: {
+        ERROR: {
+            GENERAL: 'An error occurred',
+            INVALID_INPUT: 'Invalid input provided',
+            REQUIRED_FIELD: 'This field is required'
+        },
+        SUCCESS: {
+            SAVE: 'saved successfully',
+            UPDATE: 'updated successfully',
+            DELETE: 'deleted successfully'
+        }
+    },
+    FORM: {
+        ERROR: {
+            INIT: 'Failed to initialize form',
+            SAVE: 'Failed to save',
+            LOAD: 'Failed to load',
+            VALIDATION: 'Please fill in all required fields correctly'
+        },
+        SUCCESS: {
+            SAVE: 'saved successfully'
+        }
+    },
+    LIST: {
+        ERROR: {
+            LOAD: 'Failed to load',
+            DELETE: 'Failed to delete',
+            NAVIGATION: 'Navigation failed',
+            INVALID_ID: 'Cannot perform action without ID'
+        },
+        SUCCESS: {
+            DELETE: 'deleted successfully'
+        }
+    }
+};
+
+var ComponentContext;
+(function (ComponentContext) {
+    ComponentContext["STANDALONE"] = "STANDALONE";
+    ComponentContext["TABBED"] = "TABBED";
+    ComponentContext["MODAL"] = "MODAL";
+    ComponentContext["EMBEDDED"] = "EMBEDDED";
+})(ComponentContext || (ComponentContext = {}));
+
+var TabbedFormType;
+(function (TabbedFormType) {
+    TabbedFormType["STANDARD"] = "STANDARD";
+    TabbedFormType["LIST"] = "LIST";
+})(TabbedFormType || (TabbedFormType = {}));
+
 /**
- * A utility service that provides common reusable functionality
- * such as UUID validation and error message display
+ * Standard task roles that define user permissions within a task workflow.
+ * These roles control what operations a user can perform on tasks.
  */
-class UtilsService {
-    /**
-     * Validates if a string is a valid UUID
-     * @param uuid The string to validate
-     * @returns boolean indicating if the string is a valid UUID
-     */
-    isValidUUID(uuid) {
-        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-        return uuidRegex.test(uuid);
-    }
+var TaskRole;
+(function (TaskRole) {
     /**
-     * Shows an error message using PrimeNG's MessageService
-     * @param message The error message to display
-     * @param messageService The MessageService instance to use
+     * Can create new tasks. This could be a user initiating a task manually
+     * or a system process creating tasks automatically.
      */
-    showError(message, messageService) {
-        if (messageService) {
-            messageService.add({
-                severity: 'error',
-                summary: 'Error',
-                detail: message,
-                life: 3000
-            });
-        }
-    }
+    TaskRole["TASK_CREATOR"] = "TASK_CREATOR";
     /**
-     * Shows a success message using PrimeNG's MessageService
-     * @param message The success message to display
-     * @param messageService The MessageService instance to use
+     * Can assign or reassign tasks to other users. Typically used by
+     * team leads or workflow managers to distribute work.
      */
-    showSuccess(message, messageService) {
-        if (messageService) {
-            messageService.add({
-                severity: 'success',
-                summary: 'Success',
-                detail: message,
-                life: 3000
-            });
-        }
-    }
+    TaskRole["TASK_ASSIGNER"] = "TASK_ASSIGNER";
     /**
-     * Gets the display value for an enum key or array of enum keys
-     * @param enumType The enum type
-     * @param key The enum key or array of enum keys
-     * @returns The display value for the enum key or comma-separated list of display values for array of keys
+     * Can pick tasks for self-assignment from a task pool.
+     * Useful in scenarios where tasks can be claimed by available workers.
      */
-    getEnumValue(enumType, key) {
-        if (!key)
-            return '';
-        if (Array.isArray(key)) {
-            // Handle array of keys - map each to its display value and join with comma
-            return key.map(k => enumType[k] || k).join(', ');
-        }
-        // Handle single key
-        return enumType[key] || key;
-    }
+    TaskRole["TASK_PICKER"] = "TASK_PICKER";
     /**
-     * Gets all values from an enum type for use in formly select fields
-     * @param enumType The enum type to get values from
-     * @returns Array of {label, value} pairs for formly select options
+     * Can review and approve completed tasks. This role is responsible for
+     * quality assurance or approval steps in the workflow.
      */
-    getEnumValues(enumType) {
-        return Object.entries(enumType)
-            .filter(([key]) => isNaN(Number(key))) // Filter out reverse mappings
-            .map(([key, value]) => ({
-            value: key, // enum key as the value
-            label: value // enum value as the label
-        }));
-    }
+    TaskRole["TASK_REVIEWER"] = "TASK_REVIEWER";
     /**
-     * Converts a camelCase string to Title Case with spaces
-     * @param camelCase The camelCase string to convert
-     * @returns The Title Case string
+     * Can view task details but cannot modify them. Useful for stakeholders
+     * who need to monitor task progress without making changes.
      */
-    camelCaseToTitleCase(camelCase) {
-        if (!camelCase)
-            return '';
-        const spacedString = camelCase.replace(/([a-z])([A-Z])/g, '$1 $2');
-        return spacedString.charAt(0).toUpperCase() + spacedString.slice(1);
-    }
+    TaskRole["TASK_VIEWER"] = "TASK_VIEWER";
     /**
-     * Converts a string to kebab-case
-     * @param input The string to convert
-     * @returns The kebab-case string
+     * Has full administrative control over tasks. Can override or force
+     * state changes, bypass normal workflow restrictions, and manage
+     * task configuration.
      */
-    toKebabCase(input) {
-        return input
-            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-            .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2')
-            .toLowerCase();
+    TaskRole["TASK_ADMIN"] = "TASK_ADMIN";
+})(TaskRole || (TaskRole = {}));
+
+const KEYCLOAK_CONFIG = new InjectionToken('KEYCLOAK_CONFIG');
+
+class KeycloakService {
+    config;
+    http;
+    keycloak;
+    isAuthenticated$ = new BehaviorSubject(false);
+    userProfile$ = new BehaviorSubject(null);
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
     }
-    /**
-     * Converts a string to camelCase.
-     * Example: "loan-application" becomes "loanApplication"
-     * @param input The string to convert
-     * @returns The camelCase string
-     */
-    toCamelCase(input) {
-        if (!input)
-            return '';
-        // Split by non-alphanumeric chars
-        const words = input.split(/[^a-zA-Z0-9]/);
-        const result = [words[0].toLowerCase()];
-        // Capitalize first letter of remaining words
-        for (let i = 1; i < words.length; i++) {
-            const word = words[i];
-            if (word) {
-                result.push(word.charAt(0).toUpperCase() + word.substring(1).toLowerCase());
+    async initialize() {
+        try {
+            this.keycloak = new Keycloak(this.config);
+            const authenticated = await this.keycloak.init({
+                onLoad: 'check-sso',
+                silentCheckSsoRedirectUri: this.config.silentCheckSsoRedirectUri
+            });
+            this.isAuthenticated$.next(authenticated);
+            if (authenticated) {
+                await this.loadUserProfile();
             }
+            return authenticated;
+        }
+        catch (error) {
+            console.error('Failed to initialize Keycloak:', error);
+            return false;
         }
-        return result.join('');
     }
-    /**
-     * Removes double forward slashes from an endpoint string while preserving the protocol
-     * e.g. "http://localhost:8080//api//v1//users" -> "http://localhost:8080/api/v1/users"
-     * @param endpoint The endpoint string to clean
-     * @returns The cleaned endpoint string without double slashes
-     */
-    removeDoubleSlashes(endpoint) {
-        if (!endpoint)
-            return '';
-        // Split the URL into protocol and the rest to preserve protocol slashes
-        const [protocol, ...rest] = endpoint.split('://');
-        if (!rest.length) {
-            // If no protocol is present, just clean the entire string
-            return endpoint.replace(/\/+/g, '/');
+    login(options = {}) {
+        const loginOptions = {
+            ...this.config.loginOptions,
+            ...options
+        };
+        return this.keycloak.login(loginOptions);
+    }
+    logout() {
+        return this.keycloak.logout();
+    }
+    isLoggedIn() {
+        return this.isAuthenticated$.asObservable();
+    }
+    async getToken() {
+        try {
+            await this.updateToken(this.config.tokenValidityInSeconds || 60);
+            return this.keycloak.token;
+        }
+        catch (error) {
+            console.error('Failed to get token:', error);
+            return null;
         }
-        // Clean the path part (after protocol) and reconstruct the URL
-        const cleanPath = rest.join('://').replace(/\/+/g, '/');
-        return `${protocol}://${cleanPath}`;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: UtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: UtilsService, providedIn: 'root' });
+    getRoles() {
+        if (!this.keycloak?.realmAccess?.roles) {
+            return [];
+        }
+        return this.keycloak.realmAccess.roles;
+    }
+    hasRole(role) {
+        return this.getRoles().includes(role);
+    }
+    getUserProfile() {
+        return this.userProfile$.asObservable();
+    }
+    updateToken(minValidity = 60) {
+        return new Promise((resolve, reject) => {
+            if (!this.keycloak?.token) {
+                resolve(false);
+                return;
+            }
+            this.keycloak.updateToken(minValidity)
+                .then((refreshed) => {
+                resolve(refreshed);
+            })
+                .catch((error) => {
+                console.error('Failed to update token:', error);
+                reject(error);
+            });
+        });
+    }
+    async loadUserProfile() {
+        try {
+            const profile = await this.keycloak.loadUserProfile();
+            this.userProfile$.next(profile);
+        }
+        catch (error) {
+            console.error('Failed to load user profile:', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakService, deps: [{ token: KEYCLOAK_CONFIG }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: UtilsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakService, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [KEYCLOAK_CONFIG]
+                }] }, { type: i1.HttpClient }] });
 
-class EnumRegistryService {
-    utilsService;
-    enumMap = new Map();
-    constructor(utilsService) {
-        this.utilsService = utilsService;
+class KeycloakAuthGuard {
+    keycloakService;
+    router;
+    constructor(keycloakService, router) {
+        this.keycloakService = keycloakService;
+        this.router = router;
     }
-    /**
-     * Initialize global enums
-     */
-    static registerGlobalEnums(enums) {
-        return {
-            provide: EnumRegistryService,
-            useFactory: (utilsService) => {
-                const service = new EnumRegistryService(utilsService);
-                Object.entries(enums).forEach(([name, enumType]) => {
-                    service.register(name, enumType);
+    canActivate(route, state) {
+        return this.keycloakService.isLoggedIn().pipe(map(authenticated => {
+            // Handle authentication check
+            if (!authenticated) {
+                this.keycloakService.login({
+                    redirectUri: window.location.origin + state.url
                 });
-                return service;
-            },
-            deps: [UtilsService]
-        };
+                return false;
+            }
+            // Handle role-based access
+            const requiredRoles = route.data['roles'];
+            if (requiredRoles && !this.hasRequiredRoles(requiredRoles)) {
+                // Redirect to unauthorized page if roles don't match
+                return this.router.createUrlTree(['/unauthorized']);
+            }
+            return true;
+        }));
+    }
+    hasRequiredRoles(requiredRoles) {
+        const userRoles = this.keycloakService.getRoles();
+        return requiredRoles.every(role => userRoles.includes(role));
     }
     /**
-     * Register an enum type with the service
-     * @param name Name to register the enum under
-     * @param enumType The enum type to register
+     * Checks if all required roles are present
+     * @param route Route being activated
+     * @returns true if no roles are required or if all required roles are present
      */
-    register(name, enumType) {
-        this.enumMap.set(name, enumType);
+    checkRoles(route) {
+        const requiredRoles = route.data['roles'];
+        if (!requiredRoles || requiredRoles.length === 0) {
+            return true;
+        }
+        return this.hasRequiredRoles(requiredRoles);
     }
     /**
-     * Get formly-compatible options array for a registered enum
-     * @param name Name of the registered enum
-     * @returns Array of {label, value} pairs suitable for formly select fields
+     * Gets redirect URL from route if present
+     * @param state Router state
+     * @returns URL to redirect to after login or undefined
      */
-    getEnumValues(name) {
-        const enumType = this.enumMap.get(name);
-        if (!enumType) {
-            console.warn(`Enum type "${name}" not found in registry`);
-            return [];
-        }
-        return this.utilsService.getEnumValues(enumType);
-    }
-    /**
-     * Check if an enum type is registered
-     * @param name Name of the enum to check
-     */
-    hasEnum(name) {
-        return this.enumMap.has(name);
-    }
-    /**
-     * Clear all registered enums
-     */
-    clear() {
-        this.enumMap.clear();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EnumRegistryService, deps: [{ token: UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EnumRegistryService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EnumRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: UtilsService }] });
-
-class FormlyConfigService {
-    enumRegistry;
-    constructor(enumRegistry) {
-        this.enumRegistry = enumRegistry;
-    }
-    getFormConfig(fields, mode, dynamicOptions) {
-        const commonConfig = {
-            props: {
-                disabled: mode === 'view'
-            }
-        };
-        return fields.map((field) => {
-            // Apply dynamic options from child component
-            if (dynamicOptions && field.key && typeof field.key === 'string') {
-                const fieldOptions = dynamicOptions[field.key];
-                if (fieldOptions) {
-                    field.props = {
-                        ...field.props,
-                        ...fieldOptions
-                    };
-                }
-            }
-            // Handle field groups recursively
-            if (field.fieldGroup) {
-                field.fieldGroup = this.getFormConfig(field.fieldGroup, mode, dynamicOptions);
-            }
-            return {
-                ...field,
-                ...commonConfig,
-                props: {
-                    ...field.props,
-                    ...commonConfig.props
-                }
-            };
-        });
+    getLoginRedirectUrl(state) {
+        return window.location.origin + state.url;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormlyConfigService, deps: [{ token: EnumRegistryService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormlyConfigService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthGuard, deps: [{ token: KeycloakService }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthGuard, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormlyConfigService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: KeycloakAuthGuard, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: EnumRegistryService }] });
-
-class NotificationService {
-    messageService;
-    messageSubject = new BehaviorSubject(null);
-    message$ = this.messageSubject.asObservable();
-    constructor(messageService) {
-        this.messageService = messageService;
-    }
-    showSuccess(message) {
-        const msgObj = {
-            severity: 'success',
-            summary: 'Success',
-            detail: message,
-            life: 3000
-        };
-        this.messageSubject.next(msgObj);
-    }
-    showError(message) {
-        const msgObj = {
-            severity: 'error',
-            summary: 'Error',
-            detail: message,
-            life: 3000
-        };
-        this.messageSubject.next(msgObj);
-    }
-    clearMessage() {
-        this.messageSubject.next(null);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NotificationService, deps: [{ token: i1.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NotificationService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NotificationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.MessageService }] });
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: KeycloakService }, { type: i1$1.Router }] });
 
 /**
  * A general-purpose HTTP utility service that provides enhanced HTTP operations
@@ -601,7 +570,7 @@ class HttpUtilityService {
             });
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: HttpUtilityService, deps: [{ token: i1$1.HttpClient }, { token: i1.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: HttpUtilityService, deps: [{ token: i1.HttpClient }, { token: i2.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: HttpUtilityService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: HttpUtilityService, decorators: [{
@@ -609,547 +578,1487 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: i1$1.HttpClient }, { type: i1.MessageService }] });
-
-class ReferenceDataProviderService {
-    endpoints = {};
-    // Method to set/update endpoints
-    setEndpoints(endpoints) {
-        this.endpoints = { ...this.endpoints, ...endpoints };
-    }
-    getReferenceEndpoint(entityName) {
-        console.log('getReferenceEndpoint', entityName, this.endpoints);
-        let endpoint = this.endpoints[entityName];
-        if (endpoint != null && endpoint.length > 0) {
-            if (endpoint.startsWith('http://') || endpoint.startsWith('https://')) {
-                return endpoint; // Absolute URL
-            }
-            else {
-                // Relative URL, assume it's within the application's base context
-                return endpoint;
-            }
-        }
-        return null;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: ReferenceDataProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: ReferenceDataProviderService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: ReferenceDataProviderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.MessageService }] });
 
-class EntityRegistryService {
-    httpUtility;
-    dataProvider;
-    constructor(httpUtility, dataProvider) {
-        this.httpUtility = httpUtility;
-        this.dataProvider = dataProvider;
+/**
+ * A utility service that provides common reusable functionality
+ * such as UUID validation and error message display
+ */
+class UtilsService {
+    /**
+     * Validates if a string is a valid UUID
+     * @param uuid The string to validate
+     * @returns boolean indicating if the string is a valid UUID
+     */
+    isValidUUID(uuid) {
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(uuid);
     }
     /**
-     * Gets reference options for an entity, suitable for select/dropdown components
-     * @param entityName The name of the entity (e.g., 'customers', 'departments')
-     * @returns Observable of options array with label/value pairs
+     * Shows an error message using PrimeNG's MessageService
+     * @param message The error message to display
+     * @param messageService The MessageService instance to use
      */
-    getEntityOptions(entityName) {
-        console.log('getEntityOptions', entityName);
-        const url = this.dataProvider.getReferenceEndpoint(entityName);
-        if (!url) {
-            console.warn(`No endpoint configured for entity: ${entityName}`);
-            return new Observable(subscriber => {
-                subscriber.next([]);
-                subscriber.complete();
+    showError(message, messageService) {
+        if (messageService) {
+            messageService.add({
+                severity: 'error',
+                summary: 'Error',
+                detail: message,
+                life: 3000
             });
         }
-        return this.httpUtility.get(url, {
-            retries: 1,
-            timeoutMs: 10000,
-        }).pipe(map((items) => items?.map((item) => ({
-            label: item.displayLabel,
-            value: item.key,
-            data: item.data,
-        })) || []));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EntityRegistryService, deps: [{ token: HttpUtilityService }, { token: ReferenceDataProviderService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EntityRegistryService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EntityRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: HttpUtilityService }, { type: ReferenceDataProviderService }] });
-
-class BaseCrudService {
-    httpUtility;
-    utilsService;
-    resourcePath;
-    backendBaseUrl;
-    messageService;
-    // Use the loading state from HttpUtilityService
-    get loading$() {
-        return this.httpUtility.loading$;
     }
-    apiUrl;
     /**
-     * Creates an instance of BaseCrudService.
-     * @param httpUtility - Service for making HTTP requests
-     * @param utilsService - Utility service for common operations
-     * @param resourcePath - API resource path (e.g., 'customers', 'products')
-     * @param backendBaseUrl - Base URL for the backend API
-     * @param messageService - Optional service for showing messages
+     * Shows a success message using PrimeNG's MessageService
+     * @param message The success message to display
+     * @param messageService The MessageService instance to use
      */
-    constructor(httpUtility, utilsService, resourcePath, backendBaseUrl, messageService) {
-        this.httpUtility = httpUtility;
-        this.utilsService = utilsService;
-        this.resourcePath = resourcePath;
-        this.backendBaseUrl = backendBaseUrl;
-        this.messageService = messageService;
-        this.apiUrl = this.joinUrls(backendBaseUrl, resourcePath);
+    showSuccess(message, messageService) {
+        if (messageService) {
+            messageService.add({
+                severity: 'success',
+                summary: 'Success',
+                detail: message,
+                life: 3000
+            });
+        }
     }
     /**
-     * Joins URL parts ensuring no double slashes
+     * Gets the display value for an enum key or array of enum keys
+     * @param enumType The enum type
+     * @param key The enum key or array of enum keys
+     * @returns The display value for the enum key or comma-separated list of display values for array of keys
      */
-    joinUrls(...parts) {
-        return parts.map(part => part.replace(/^\/+|\/+$/g, '')).join('/');
-    }
-    getAll(pageRequest) {
-        if (pageRequest) {
-            return this.httpUtility.post(`${this.apiUrl}/page`, pageRequest);
-        }
-        else {
-            return this.httpUtility.get(this.apiUrl);
+    getEnumValue(enumType, key) {
+        if (!key)
+            return '';
+        if (Array.isArray(key)) {
+            // Handle array of keys - map each to its display value and join with comma
+            return key.map(k => enumType[k] || k).join(', ');
         }
+        // Handle single key
+        return enumType[key] || key;
     }
-    getById(uuid) {
-        if (!this.utilsService.isValidUUID(uuid)) {
-            this.utilsService.showError('Invalid UUID format', this.messageService);
-            return throwError(() => new Error('Invalid UUID format'));
-        }
-        return this.httpUtility.get(`${this.apiUrl}/${uuid}`);
+    /**
+     * Gets all values from an enum type for use in formly select fields
+     * @param enumType The enum type to get values from
+     * @returns Array of {label, value} pairs for formly select options
+     */
+    getEnumValues(enumType) {
+        return Object.entries(enumType)
+            .filter(([key]) => isNaN(Number(key))) // Filter out reverse mappings
+            .map(([key, value]) => ({
+            value: key, // enum key as the value
+            label: value // enum value as the label
+        }));
     }
-    create(entity) {
-        return this.httpUtility.post(this.apiUrl, entity);
+    /**
+     * Converts a camelCase string to Title Case with spaces
+     * @param camelCase The camelCase string to convert
+     * @returns The Title Case string
+     */
+    camelCaseToTitleCase(camelCase) {
+        if (!camelCase)
+            return '';
+        const spacedString = camelCase.replace(/([a-z])([A-Z])/g, '$1 $2');
+        return spacedString.charAt(0).toUpperCase() + spacedString.slice(1);
     }
-    update(uuid, entity) {
-        if (!this.utilsService.isValidUUID(uuid)) {
-            this.utilsService.showError('Invalid UUID format', this.messageService);
-            return throwError(() => new Error('Invalid UUID format'));
-        }
-        return this.httpUtility.put(`${this.apiUrl}/${uuid}`, entity);
+    /**
+     * Converts a string to kebab-case
+     * @param input The string to convert
+     * @returns The kebab-case string
+     */
+    toKebabCase(input) {
+        return input
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+            .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2')
+            .toLowerCase();
     }
-    delete(uuid) {
-        if (!this.utilsService.isValidUUID(uuid)) {
-            this.utilsService.showError('Invalid UUID format', this.messageService);
-            return throwError(() => new Error('Invalid UUID format'));
+    /**
+     * Converts a string to camelCase.
+     * Example: "loan-application" becomes "loanApplication"
+     * @param input The string to convert
+     * @returns The camelCase string
+     */
+    toCamelCase(input) {
+        if (!input)
+            return '';
+        // Split by non-alphanumeric chars
+        const words = input.split(/[^a-zA-Z0-9]/);
+        const result = [words[0].toLowerCase()];
+        // Capitalize first letter of remaining words
+        for (let i = 1; i < words.length; i++) {
+            const word = words[i];
+            if (word) {
+                result.push(word.charAt(0).toUpperCase() + word.substring(1).toLowerCase());
+            }
         }
-        return this.httpUtility.delete(`${this.apiUrl}/${uuid}`);
+        return result.join('');
+    }
+    /**
+     * Removes double forward slashes from an endpoint string while preserving the protocol
+     * e.g. "http://localhost:8080//api//v1//users" -> "http://localhost:8080/api/v1/users"
+     * @param endpoint The endpoint string to clean
+     * @returns The cleaned endpoint string without double slashes
+     */
+    removeDoubleSlashes(endpoint) {
+        if (!endpoint)
+            return '';
+        // Split the URL into protocol and the rest to preserve protocol slashes
+        const [protocol, ...rest] = endpoint.split('://');
+        if (!rest.length) {
+            // If no protocol is present, just clean the entire string
+            return endpoint.replace(/\/+/g, '/');
+        }
+        // Clean the path part (after protocol) and reconstruct the URL
+        const cleanPath = rest.join('://').replace(/\/+/g, '/');
+        return `${protocol}://${cleanPath}`;
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: UtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: UtilsService, providedIn: 'root' });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
 
-var ComponentContext;
-(function (ComponentContext) {
-    ComponentContext["STANDALONE"] = "STANDALONE";
-    ComponentContext["TABBED"] = "TABBED";
-    ComponentContext["MODAL"] = "MODAL";
-    ComponentContext["EMBEDDED"] = "EMBEDDED";
-})(ComponentContext || (ComponentContext = {}));
-
-var TabbedFormType;
-(function (TabbedFormType) {
-    TabbedFormType["STANDARD"] = "STANDARD";
-    TabbedFormType["LIST"] = "LIST";
-})(TabbedFormType || (TabbedFormType = {}));
+class NotificationService {
+    messageService;
+    messageSubject = new BehaviorSubject(null);
+    message$ = this.messageSubject.asObservable();
+    constructor(messageService) {
+        this.messageService = messageService;
+    }
+    showSuccess(message) {
+        const msgObj = {
+            severity: 'success',
+            summary: 'Success',
+            detail: message,
+            life: 3000
+        };
+        this.messageSubject.next(msgObj);
+    }
+    showError(message) {
+        const msgObj = {
+            severity: 'error',
+            summary: 'Error',
+            detail: message,
+            life: 3000
+        };
+        this.messageSubject.next(msgObj);
+    }
+    clearMessage() {
+        this.messageSubject.next(null);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NotificationService, deps: [{ token: i2.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NotificationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i2.MessageService }] });
 
-/**
- * Base component for all page components in the application.
- * Provides common functionality like loading state and message display.
- */
-class BasePageComponent {
+class BaseCrudService {
+    httpUtility;
     utilsService;
-    notificationService;
-    loading = false;
-    constructor(utilsService, notificationService) {
-        this.utilsService = utilsService;
-        this.notificationService = notificationService;
+    resourcePath;
+    backendBaseUrl;
+    messageService;
+    // Use the loading state from HttpUtilityService
+    get loading$() {
+        return this.httpUtility.loading$;
     }
+    apiUrl;
     /**
-     * Display an error message to the user
-     * @param detail The error message to display
+     * Creates an instance of BaseCrudService.
+     * @param httpUtility - Service for making HTTP requests
+     * @param utilsService - Utility service for common operations
+     * @param resourcePath - API resource path (e.g., 'customers', 'products')
+     * @param backendBaseUrl - Base URL for the backend API
+     * @param messageService - Optional service for showing messages
      */
-    showError(detail) {
-        this.notificationService.showError(detail);
+    constructor(httpUtility, utilsService, resourcePath, backendBaseUrl, messageService) {
+        this.httpUtility = httpUtility;
+        this.utilsService = utilsService;
+        this.resourcePath = resourcePath;
+        this.backendBaseUrl = backendBaseUrl;
+        this.messageService = messageService;
+        this.apiUrl = this.joinUrls(backendBaseUrl, resourcePath);
     }
     /**
-     * Display a success message to the user
-     * @param detail The success message to display
+     * Joins URL parts ensuring no double slashes
      */
-    showSuccess(detail) {
-        this.notificationService.showSuccess(detail);
+    joinUrls(...parts) {
+        return parts.map(part => part.replace(/^\/+|\/+$/g, '')).join('/');
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BasePageComponent, deps: [{ token: UtilsService }, { token: NotificationService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.6", type: BasePageComponent, isStandalone: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BasePageComponent, decorators: [{
-            type: Directive
-        }], ctorParameters: () => [{ type: UtilsService }, { type: NotificationService }] });
-
-const AppMessages = {
-    COMMON: {
-        ERROR: {
-            GENERAL: 'An error occurred',
-            INVALID_INPUT: 'Invalid input provided',
-            REQUIRED_FIELD: 'This field is required'
-        },
-        SUCCESS: {
-            SAVE: 'saved successfully',
-            UPDATE: 'updated successfully',
-            DELETE: 'deleted successfully'
+    getAll(pageRequest) {
+        if (pageRequest) {
+            return this.httpUtility.post(`${this.apiUrl}/page`, pageRequest);
         }
-    },
-    FORM: {
-        ERROR: {
-            INIT: 'Failed to initialize form',
-            SAVE: 'Failed to save',
-            LOAD: 'Failed to load',
-            VALIDATION: 'Please fill in all required fields correctly'
-        },
-        SUCCESS: {
-            SAVE: 'saved successfully'
+        else {
+            return this.httpUtility.get(this.apiUrl);
         }
-    },
-    LIST: {
-        ERROR: {
-            LOAD: 'Failed to load',
-            DELETE: 'Failed to delete',
-            NAVIGATION: 'Navigation failed',
-            INVALID_ID: 'Cannot perform action without ID'
-        },
-        SUCCESS: {
-            DELETE: 'deleted successfully'
+    }
+    getById(uuid) {
+        if (!this.utilsService.isValidUUID(uuid)) {
+            this.utilsService.showError('Invalid UUID format', this.messageService);
+            return throwError(() => new Error('Invalid UUID format'));
         }
+        return this.httpUtility.get(`${this.apiUrl}/${uuid}`);
+    }
+    create(entity) {
+        return this.httpUtility.post(this.apiUrl, entity);
+    }
+    update(uuid, entity) {
+        if (!this.utilsService.isValidUUID(uuid)) {
+            this.utilsService.showError('Invalid UUID format', this.messageService);
+            return throwError(() => new Error('Invalid UUID format'));
+        }
+        return this.httpUtility.put(`${this.apiUrl}/${uuid}`, entity);
+    }
+    delete(uuid) {
+        if (!this.utilsService.isValidUUID(uuid)) {
+            this.utilsService.showError('Invalid UUID format', this.messageService);
+            return throwError(() => new Error('Invalid UUID format'));
+        }
+        return this.httpUtility.delete(`${this.apiUrl}/${uuid}`);
     }
-};
-
-class AppConstants {
-    static FORM = {
-        MODE: 'mode',
-        UUID: 'uuid',
-        NEW: 'new'
-    };
-    static PAGE_MODE = {
-        CREATE: 'create',
-        EDIT: 'edit',
-        VIEW: 'view'
-    };
 }
 
-class BaseFormComponent extends BasePageComponent {
-    route;
-    router;
-    notificationService;
+/**
+ * Base service for task-related operations that extends the BaseCrudService.
+ * Implements endpoints defined in Java BaseTaskController.
+ */
+class BaseTaskService extends BaseCrudService {
+    httpUtility;
     utilsService;
-    formlyConfigService;
-    // form = new FormGroup({});
-    form = new FormGroup({});
-    fields = [];
-    isNew = true;
-    mode = AppConstants.PAGE_MODE.CREATE;
-    currentFormData = {};
-    originalFormData = null;
-    hasChanges = false;
-    context = ComponentContext.STANDALONE;
-    constructor(route, router, notificationService, utilsService, formlyConfigService) {
-        super(utilsService, notificationService);
-        this.route = route;
-        this.router = router;
-        this.notificationService = notificationService;
+    resourcePath;
+    backendBaseUrl;
+    messageService;
+    constructor(httpUtility, utilsService, resourcePath, backendBaseUrl, messageService) {
+        super(httpUtility, utilsService, resourcePath, backendBaseUrl, messageService);
+        this.httpUtility = httpUtility;
         this.utilsService = utilsService;
-        this.formlyConfigService = formlyConfigService;
+        this.resourcePath = resourcePath;
+        this.backendBaseUrl = backendBaseUrl;
+        this.messageService = messageService;
     }
-    ngOnInit() {
-        try {
-            this.fields = this.getFormlyFieldConfig();
-            this.form.valueChanges.subscribe(() => {
-                console.log('[BaseFormComponent] Form value changed:', this.form.value);
-                this.currentFormData = { ...this.form.value };
-                this.hasChanges = this.hasFormChanges(this.currentFormData);
-            });
-            // Use queryParams instead of params
-            this.route.queryParams.pipe(take(1)).subscribe({
-                next: params => this.initializeForm(params),
-                error: error => {
-                    console.error('Error initializing form:', error);
-                    this.showError(AppMessages.FORM.ERROR.INIT);
-                }
-            });
+    /**
+     * Find tasks by department with pagination
+     * Maps to GET /department/{department} endpoint
+     */
+    findByDepartment(department, pageRequest) {
+        if (pageRequest) {
+            return this.httpUtility.post(`${this.apiUrl}/department/${department}/page`, pageRequest);
         }
-        catch (error) {
-            console.error('Error in ngOnInit:', error);
-            this.showError(AppMessages.FORM.ERROR.INIT);
+        return this.httpUtility.get(`${this.apiUrl}/department/${department}`);
+    }
+    /**
+     * Find tasks by assigned user with pagination
+     * Maps to GET /user/{userId} endpoint
+     */
+    findByAssignedUser(userId, pageRequest) {
+        if (pageRequest) {
+            return this.httpUtility.post(`${this.apiUrl}/user/${userId}/page`, pageRequest);
         }
+        return this.httpUtility.get(`${this.apiUrl}/user/${userId}`);
     }
-    initializeFormData() {
-        console.log('[BaseFormComponent] Initializing form data');
-        console.log('[BaseFormComponent] Current mode:', this.mode);
-        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
-            console.log('[BaseFormComponent] Create mode, using defaults');
-            return;
+    /**
+     * Send an event for a task
+     * Maps to PUT /{uuid}/event/{event} endpoint
+     * For ASSIGN events, userId and department are required
+     */
+    sendEvent(uuid, event, userId, department) {
+        if (!this.utilsService.isValidUUID(uuid)) {
+            this.utilsService.showError('Invalid UUID format', this.messageService);
+            throw new Error('Invalid UUID format');
         }
-        const state = {
-            ...this.router.getCurrentNavigation()?.extras?.state,
-            ...window.history.state,
-            ...this.route.snapshot.data
-        };
-        console.log('[BaseFormComponent] Combined state:', state);
-        console.log('[BaseFormComponent] Final state being used:', state);
-        if (state && 'formData' in state) {
-            console.log('[BaseFormComponent] Found form data in state:', state['formData']);
-            this.patchFormData(state['formData']);
+        let params = new HttpParams();
+        if (userId) {
+            params = params.set('userId', userId);
         }
-        else {
-            console.log('[BaseFormComponent] No form data, loading from UUID');
-            this.loadFromUuid();
+        if (department) {
+            params = params.set('department', department);
         }
+        return this.httpUtility.put(`${this.apiUrl}/${uuid}/event/${event}`, null, { params });
     }
-    loadFromUuid() {
-        this.route.queryParams.pipe(take(1)).subscribe(params => {
-            const uuid = params[AppConstants.FORM.UUID];
-            if (!uuid) {
-                throw new Error(`UUID is required for ${this.mode} mode when no formData is provided`);
-            }
-            this.loadEntity(uuid);
-        });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTaskService, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTaskService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTaskService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: HttpUtilityService }, { type: UtilsService }, { type: undefined }, { type: undefined }, { type: undefined }] });
+
+class EnumRegistryService {
+    utilsService;
+    enumMap = new Map();
+    constructor(utilsService) {
+        this.utilsService = utilsService;
     }
-    initializeForm(params) {
-        console.log('[BaseFormComponent] Initializing form with params:', params);
-        const routeMode = params[AppConstants.FORM.MODE];
-        this.initializeFormMode(routeMode);
-        this.setupFormState();
-        // Check for context in router state
-        const state = window.history.state;
-        if (state?.context) {
-            this.context = state.context;
-            console.log('[BaseFormComponent] Context set from router state:', this.context);
+    /**
+     * Initialize global enums
+     */
+    static registerGlobalEnums(enums) {
+        return {
+            provide: EnumRegistryService,
+            useFactory: (utilsService) => {
+                const service = new EnumRegistryService(utilsService);
+                Object.entries(enums).forEach(([name, enumType]) => {
+                    service.register(name, enumType);
+                });
+                return service;
+            },
+            deps: [UtilsService]
+        };
+    }
+    /**
+     * Register an enum type with the service
+     * @param name Name to register the enum under
+     * @param enumType The enum type to register
+     */
+    register(name, enumType) {
+        this.enumMap.set(name, enumType);
+    }
+    /**
+     * Get formly-compatible options array for a registered enum
+     * @param name Name of the registered enum
+     * @returns Array of {label, value} pairs suitable for formly select fields
+     */
+    getEnumValues(name) {
+        const enumType = this.enumMap.get(name);
+        if (!enumType) {
+            console.warn(`Enum type "${name}" not found in registry`);
+            return [];
         }
-        this.initializeFormData();
+        return this.utilsService.getEnumValues(enumType);
     }
-    patchFormData(data) {
-        console.log('[BaseFormComponent] Patching form data:', data);
-        if (data) {
-            if (!this.fields || this.fields.length === 0) {
-                console.warn('[BaseFormComponent] Fields not initialized yet, reinitializing');
-                this.fields = this.getFormlyFieldConfig();
+    /**
+     * Check if an enum type is registered
+     * @param name Name of the enum to check
+     */
+    hasEnum(name) {
+        return this.enumMap.has(name);
+    }
+    /**
+     * Clear all registered enums
+     */
+    clear() {
+        this.enumMap.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EnumRegistryService, deps: [{ token: UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EnumRegistryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: EnumRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: UtilsService }] });
+
+class FormlyConfigService {
+    enumRegistry;
+    constructor(enumRegistry) {
+        this.enumRegistry = enumRegistry;
+    }
+    getFormConfig(fields, mode, dynamicOptions) {
+        const commonConfig = {
+            props: {
+                disabled: mode === 'view'
+            }
+        };
+        return fields.map((field) => {
+            // Apply dynamic options from child component
+            if (dynamicOptions && field.key && typeof field.key === 'string') {
+                const fieldOptions = dynamicOptions[field.key];
+                if (fieldOptions) {
+                    field.props = {
+                        ...field.props,
+                        ...fieldOptions
+                    };
+                }
             }
-            this.currentFormData = { ...data };
-            this.originalFormData = data;
-            this.isNew = false;
-            console.log('[BaseFormComponent] Form data updated:', this.currentFormData);
-            console.log('[BaseFormComponent] Fields available:', this.fields);
-            setTimeout(() => {
-                if (!this.form.valid) {
-                    console.warn('[BaseFormComponent] Form validation issues after data patch');
+            // Handle field groups recursively
+            if (field.fieldGroup) {
+                field.fieldGroup = this.getFormConfig(field.fieldGroup, mode, dynamicOptions);
+            }
+            return {
+                ...field,
+                ...commonConfig,
+                props: {
+                    ...field.props,
+                    ...commonConfig.props
                 }
-                console.log('[BaseFormComponent] Form state after sync:', {
-                    valid: this.form.valid,
-                    values: this.form.value,
-                    currentData: this.currentFormData
-                });
-            }, 100);
+            };
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormlyConfigService, deps: [{ token: EnumRegistryService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormlyConfigService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormlyConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: EnumRegistryService }] });
+
+class FormService {
+    entityService;
+    formlyConfigService;
+    notificationService;
+    entityName;
+    jsonFields;
+    dropdownOptions;
+    formState;
+    constructor(entityService, formlyConfigService, notificationService, entityName, jsonFields, dropdownOptions = {}) {
+        this.entityService = entityService;
+        this.formlyConfigService = formlyConfigService;
+        this.notificationService = notificationService;
+        this.entityName = entityName;
+        this.jsonFields = jsonFields;
+        this.dropdownOptions = dropdownOptions;
+        this.formState = {
+            form: new FormGroup({}),
+            fields: [],
+            isNew: true,
+            mode: AppConstants.PAGE_MODE.CREATE,
+            currentData: {},
+            originalData: null,
+            hasChanges: false,
+            loading: false,
+        };
+        this.initializeForm();
+    }
+    initializeForm() {
+        this.formState.fields = this.getFormlyFieldConfig();
+        if (this.formState.mode === AppConstants.PAGE_MODE.VIEW) {
+            this.formState.form.disable();
         }
     }
-    initializeFormMode(routeMode) {
-        if (!routeMode) {
-            this.mode = AppConstants.PAGE_MODE.CREATE;
+    getFormlyFieldConfig() {
+        return this.formlyConfigService.getFormConfig(this.jsonFields, this.formState.mode, this.dropdownOptions);
+    }
+    loadData(uuid) {
+        if (!uuid || this.formState.mode === AppConstants.PAGE_MODE.CREATE) {
+            return of(void 0);
+        }
+        this.formState.loading = true;
+        return this.entityService.getById(uuid).pipe(take(1), map(data => {
+            this.updateFormState(data);
+        }), finalize$1(() => this.formState.loading = false));
+    }
+    updateFormState(data) {
+        this.formState = {
+            ...this.formState,
+            currentData: { ...data },
+            originalData: data,
+            isNew: false,
+            loading: false
+        };
+        this.formState.form.patchValue(data, { emitEvent: false });
+    }
+    submit() {
+        if (!this.validateSubmission()) {
+            return of(null);
         }
-        else if (this.isValidPageMode(routeMode)) {
-            this.mode = routeMode;
+        this.formState.loading = true;
+        const operation$ = this.getSubmitOperation();
+        return operation$.pipe(finalize$1(() => this.formState.loading = false), map(result => {
+            this.notificationService.showSuccess(`${this.entityName} ${AppMessages.FORM.SUCCESS.SAVE}`);
+            return result;
+        }));
+    }
+    validateSubmission() {
+        if (!this.formState.form.valid) {
+            this.notificationService.showError('Please check form errors');
+            return false;
         }
-        else {
-            throw new Error(`Invalid page mode: ${routeMode}`);
+        if (!this.formState.hasChanges && !this.formState.isNew) {
+            this.notificationService.showSuccess('No changes to save');
+            return false;
+        }
+        if (!this.formState.currentData || Object.keys(this.formState.currentData).length === 0) {
+            this.notificationService.showError('No data to save');
+            return false;
         }
+        return true;
     }
-    setupFormState() {
-        console.log('[BaseFormComponent] Setting up form state, mode:', this.mode);
-        this.fields = this.getFormlyFieldConfig();
-        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
-            console.log('[BaseFormComponent] Create mode setup');
-            this.isNew = true;
-            this.loading = false;
-            this.originalFormData = null;
+    getSubmitOperation() {
+        const formData = this.formState.currentData;
+        return this.formState.isNew
+            ? this.entityService.create(formData)
+            : this.entityService.update(this.formState.originalData.uuid, formData);
+    }
+    setMode(mode) {
+        this.formState.mode = mode;
+        if (mode === AppConstants.PAGE_MODE.VIEW) {
+            this.formState.form.disable();
         }
-        if (this.mode === AppConstants.PAGE_MODE.VIEW) {
-            console.log('[BaseFormComponent] View mode setup');
-            this.form.disable();
+        else {
+            this.formState.form.enable();
         }
     }
-    getFormlyFieldConfig() {
-        return this.formlyConfigService.getFormConfig(this.getJsonFields(), this.mode, this.getDropdownOptions());
+    getState() {
+        return this.formState;
     }
-    onSubmitRoute() {
-        return [`/${this.getEntityName().toLowerCase()}s`];
+    patchValue(value) {
+        this.formState.form.patchValue(value);
+        this.updateCurrentData();
+        this.checkFormChanges();
     }
-    getEntityOperations() {
-        const entityService = this.getEntityService();
-        return {
-            create: (data) => entityService.create(data),
-            update: (uuid, data) => entityService.update(uuid, { ...data, uuid }),
-            getById: (uuid) => entityService.getById(uuid)
+    updateCurrentData() {
+        this.formState.currentData = {
+            ...this.formState.form.value,
+            uuid: this.formState.originalData?.uuid
         };
     }
-    onSubmit() {
-        console.log('[BaseFormComponent] Form submission:', {
-            formValid: this.form.valid,
-            formData: this.currentFormData,
-            formState: this.form.value
-        });
-        if (!this.currentFormData || Object.keys(this.currentFormData).length === 0) {
-            this.notificationService.showError('No data to save');
-            return;
-        }
-        if (this.form.valid) {
-            if (this.isNew) {
-                console.log('[BaseFormComponent] Saving new entity');
-                this.saveEntity();
-                return;
-            }
-            const hasChanges = this.hasFormChanges(this.currentFormData);
-            console.log('[BaseFormComponent] Change detection:', {
-                hasChanges,
-                currentData: this.currentFormData,
-                originalData: this.originalFormData
-            });
-            if (!hasChanges) {
-                this.notificationService.showSuccess('No changes to save');
-                return;
-            }
-            console.log('[BaseFormComponent] Saving changes');
-            this.saveEntity();
-        }
-        else {
-            console.warn('[BaseFormComponent] Form validation failed:', this.form.errors);
-            this.notificationService.showError('Please check form errors');
-        }
+    checkFormChanges() {
+        this.formState.hasChanges = this.hasFormChanges(this.formState.currentData);
     }
     hasFormChanges(currentData) {
-        if (!this.originalFormData || this.isNew) {
+        if (!this.formState.originalData || this.formState.isNew) {
             return true;
         }
-        console.log('[BaseFormComponent] Checking for changes:', {
-            currentData,
-            originalData: this.originalFormData
-        });
-        const hasChanges = Object.keys(currentData).some(key => {
+        return Object.keys(currentData).some(key => {
             const currentValue = currentData[key];
-            const originalValue = this.originalFormData[key];
-            const changed = currentValue !== originalValue;
-            if (changed) {
-                console.log(`[BaseFormComponent] Field '${key}' changed:`, {
-                    from: originalValue,
-                    to: currentValue
-                });
-            }
-            return changed;
-        });
-        console.log('[BaseFormComponent] Changes detected:', hasChanges);
-        return hasChanges;
-    }
-    saveEntity() {
-        this.loading = true;
-        const formData = this.currentFormData;
-        const entityName = this.getEntityName();
-        const entityOperations = this.getEntityOperations();
-        const request$ = this.isNew
-            ? entityOperations.create(formData)
-            : entityOperations.update(this.originalFormData.uuid, formData);
-        request$.subscribe({
-            next: () => {
-                this.loading = false;
-                this.notificationService.showSuccess(`${entityName} ${AppMessages.FORM.SUCCESS.SAVE}`);
-                this.router.navigate(this.onSubmitRoute());
-            },
-            error: (error) => {
-                const errorMessage = error.error?.message || `${AppMessages.FORM.ERROR.SAVE} ${entityName}`;
-                this.showError(errorMessage);
-                this.loading = false;
-            }
-        });
-    }
-    loadEntity(uuid) {
-        this.loading = true;
-        this.isNew = false;
-        const entityName = this.getEntityName();
-        this.getEntityOperations().getById(uuid).subscribe({
-            next: (data) => {
-                this.originalFormData = data;
-                this.currentFormData = { ...data };
-                this.loading = false;
-                console.log('[BaseFormComponent] Original data loaded:', this.originalFormData);
-                console.log('[BaseFormComponent] Form data updated:', this.currentFormData);
-            },
-            error: () => {
-                this.showError(`${AppMessages.FORM.ERROR.LOAD} ${entityName}`);
-                this.loading = false;
-            }
+            const originalValue = this.formState.originalData[key];
+            return currentValue !== originalValue;
         });
     }
-    isValidPageMode(mode) {
-        return Object.values(AppConstants.PAGE_MODE).includes(mode);
-    }
-    getDropdownOptions() {
-        return {};
-    }
-    /**
-     * Checks if the component is running in a specific context
-     * @param contextType The context type to check against
-     */
-    isInContext(contextType) {
-        return this.context === contextType;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseFormComponent, deps: [{ token: i1$2.ActivatedRoute }, { token: i1$2.Router }, { token: NotificationService }, { token: UtilsService }, { token: FormlyConfigService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: BaseFormComponent, isStandalone: true, selector: "ng-component", inputs: { context: "context" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseFormComponent });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseFormComponent, decorators: [{
-            type: Injectable
-        }, {
+
+class TextInputType extends FieldType {
+    defaultOptions = {
+        props: {
+            type: 'text',
+            placeholder: ''
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextInputType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: TextInputType, isStandalone: true, selector: "formly-field-text-input", usesInheritance: true, ngImport: i0, template: `
+    <input pInputText
+           [type]="props['type'] || 'text'"
+           [formControl]="$any(formControl)"
+           [formlyAttributes]="field"
+           [placeholder]="props['placeholder'] || ''"
+           [attr.aria-label]="props['label'] || props['placeholder'] || ''"
+           class="w-full"/>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i3.InputText, selector: "[pInputText]", inputs: ["variant", "fluid", "pSize"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextInputType, decorators: [{
             type: Component,
             args: [{
-                    template: ''
-                }]
-        }], ctorParameters: () => [{ type: i1$2.ActivatedRoute }, { type: i1$2.Router }, { type: NotificationService }, { type: UtilsService }, { type: FormlyConfigService }], propDecorators: { context: [{
-                type: Input
-            }] } });
-
-/**
- * Base component for all list page components in the application.
- * Provides common functionality for list operations like loading data,
- * pagination, sorting, and CRUD operations.
- */
-class BaseListPageComponent extends BasePageComponent {
-    router;
-    notificationService;
-    utilsService;
-    confirmationService;
-    table;
-    items = [];
-    actionLoading = false;
+                    selector: 'formly-field-text-input',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        InputTextModule
+                    ],
+                    template: `
+    <input pInputText
+           [type]="props['type'] || 'text'"
+           [formControl]="$any(formControl)"
+           [formlyAttributes]="field"
+           [placeholder]="props['placeholder'] || ''"
+           [attr.aria-label]="props['label'] || props['placeholder'] || ''"
+           class="w-full"/>
+  `
+                }]
+        }] });
+
+class SelectType extends FieldType {
+    get options$() {
+        const options = this.props['options'];
+        return isObservable(options) ? options : of(options || []);
+    }
+    defaultOptions = {
+        props: {
+            options: [],
+            optionLabel: 'label',
+            optionValue: 'value',
+            placeholder: 'Select',
+            showClear: false,
+            filter: false,
+            virtualScroll: false
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: SelectType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: SelectType, isStandalone: true, selector: "formly-field-select", usesInheritance: true, ngImport: i0, template: `
+    <ng-container *ngIf="options$ | async as options">
+      <p-select
+        [formControl]="$any(formControl)"
+        [formlyAttributes]="field"
+        [options]="options"
+        [virtualScroll]="false"
+        [showClear]="false"
+        [placeholder]="props['placeholder'] || 'Select'"
+        styleClass="w-full">
+      </p-select>
+    </ng-container>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1$3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: SelectModule }, { kind: "component", type: i4.Select, selector: "p-select", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "size", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "fluid", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: SelectType, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-field-select',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        SelectModule
+                    ],
+                    template: `
+    <ng-container *ngIf="options$ | async as options">
+      <p-select
+        [formControl]="$any(formControl)"
+        [formlyAttributes]="field"
+        [options]="options"
+        [virtualScroll]="false"
+        [showClear]="false"
+        [placeholder]="props['placeholder'] || 'Select'"
+        styleClass="w-full">
+      </p-select>
+    </ng-container>
+  `
+                }]
+        }] });
+
+class RadioType extends FieldType {
+    get options$() {
+        const options = this.props['options'];
+        return isObservable(options) ? options : of(options || []);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: RadioType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: RadioType, isStandalone: true, selector: "formly-field-radio", usesInheritance: true, ngImport: i0, template: `
+    <div class="flex flex-column gap-1">
+      <ng-container *ngIf="options$ | async as options">
+        <div *ngFor="let option of options; let i = index" class="flex align-items-center gap-2">
+          <p-radioButton
+            [name]="field.name || ''"
+            [value]="option.value"
+            [formControl]="$any(formControl)"
+            [formlyAttributes]="field"
+            [size]="'small'"
+            [inputId]="field.key + '_' + i">
+          </p-radioButton>
+          <label [for]="field.key + '_' + i" class="p-radio-label cursor-pointer">
+            {{option.label}}
+          </label>
+        </div>
+      </ng-container>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1$3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: RadioButtonModule }, { kind: "component", type: i4$1.RadioButton, selector: "p-radioButton, p-radiobutton, p-radio-button", inputs: ["value", "formControlName", "name", "disabled", "variant", "size", "tabindex", "inputId", "ariaLabelledBy", "ariaLabel", "style", "styleClass", "autofocus", "binary"], outputs: ["onClick", "onFocus", "onBlur"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: RadioType, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-field-radio',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        RadioButtonModule
+                    ],
+                    template: `
+    <div class="flex flex-column gap-1">
+      <ng-container *ngIf="options$ | async as options">
+        <div *ngFor="let option of options; let i = index" class="flex align-items-center gap-2">
+          <p-radioButton
+            [name]="field.name || ''"
+            [value]="option.value"
+            [formControl]="$any(formControl)"
+            [formlyAttributes]="field"
+            [size]="'small'"
+            [inputId]="field.key + '_' + i">
+          </p-radioButton>
+          <label [for]="field.key + '_' + i" class="p-radio-label cursor-pointer">
+            {{option.label}}
+          </label>
+        </div>
+      </ng-container>
+    </div>
+  `
+                }]
+        }] });
+
+class NumericInputType extends FieldType {
+    defaultOptions = {
+        props: {
+            min: undefined,
+            max: undefined,
+            minFractionDigits: 0,
+            maxFractionDigits: 0,
+            prefix: '',
+            suffix: '',
+            useGrouping: true
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NumericInputType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: NumericInputType, isStandalone: true, selector: "formly-field-numeric-input", usesInheritance: true, ngImport: i0, template: `
+    <p-inputNumber
+      [formControl]="$any(formControl)"
+      [formlyAttributes]="field"
+      [placeholder]="props['placeholder'] || ''"
+      [min]="props['min'] || 0"
+      [max]="props['max']"
+      [minFractionDigits]="props['minFractionDigits'] || 0"
+      [maxFractionDigits]="props['maxFractionDigits'] || 0"
+      [prefix]="props['prefix'] || ''"
+      [suffix]="props['suffix'] || ''"
+      [useGrouping]="props['useGrouping'] ?? true"
+      [showButtons]="true"
+      class="w-full">
+    </p-inputNumber>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: InputNumberModule }, { kind: "component", type: i3$1.InputNumber, selector: "p-inputNumber, p-inputnumber, p-input-number", inputs: ["showButtons", "format", "buttonLayout", "inputId", "styleClass", "style", "placeholder", "size", "maxlength", "tabindex", "title", "ariaLabelledBy", "ariaLabel", "ariaRequired", "name", "required", "autocomplete", "min", "max", "incrementButtonClass", "decrementButtonClass", "incrementButtonIcon", "decrementButtonIcon", "readonly", "step", "allowEmpty", "locale", "localeMatcher", "mode", "currency", "currencyDisplay", "useGrouping", "variant", "minFractionDigits", "maxFractionDigits", "prefix", "suffix", "inputStyle", "inputStyleClass", "showClear", "autofocus", "disabled", "fluid"], outputs: ["onInput", "onFocus", "onBlur", "onKeyDown", "onClear"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NumericInputType, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-field-numeric-input',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        InputNumberModule
+                    ],
+                    template: `
+    <p-inputNumber
+      [formControl]="$any(formControl)"
+      [formlyAttributes]="field"
+      [placeholder]="props['placeholder'] || ''"
+      [min]="props['min'] || 0"
+      [max]="props['max']"
+      [minFractionDigits]="props['minFractionDigits'] || 0"
+      [maxFractionDigits]="props['maxFractionDigits'] || 0"
+      [prefix]="props['prefix'] || ''"
+      [suffix]="props['suffix'] || ''"
+      [useGrouping]="props['useGrouping'] ?? true"
+      [showButtons]="true"
+      class="w-full">
+    </p-inputNumber>
+  `
+                }]
+        }] });
+
+class MultiselectType extends FieldType {
+    get options$() {
+        const options = this.props['options'];
+        return isObservable(options) ? options : of(options || []);
+    }
+    defaultOptions = {
+        props: {
+            options: [],
+            optionLabel: 'label',
+            optionValue: 'value',
+            placeholder: 'Select',
+            filter: false,
+            maxSelectedLabels: 3,
+            showToggleAll: true,
+            virtualScroll: false
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: MultiselectType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: MultiselectType, isStandalone: true, selector: "formly-field-multiselect", usesInheritance: true, ngImport: i0, template: `
+    <ng-container *ngIf="options$ | async as options">
+      <p-multiSelect
+        [formControl]="$any(formControl)"
+        [formlyAttributes]="field"
+        [options]="options"
+        [optionLabel]="props['optionLabel'] || 'label'"
+        [optionValue]="props['optionValue'] || 'value'"
+        [placeholder]="props['placeholder'] || 'Select'"
+        [filter]="props['filter'] || true"
+        [filterBy]="props['filterBy'] || 'label'"
+        [maxSelectedLabels]="props['maxSelectedLabels'] || 2"
+        [showToggleAll]="props['showToggleAll'] || true"
+        [virtualScroll]="props['virtualScroll'] || false"
+        [display]="props['display'] || 'chip'"
+        styleClass="w-full">
+      </p-multiSelect>
+    </ng-container>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1$3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: MultiSelectModule }, { kind: "component", type: i4$2.MultiSelect, selector: "p-multiSelect, p-multiselect, p-multi-select", inputs: ["id", "ariaLabel", "style", "styleClass", "panelStyle", "panelStyleClass", "inputId", "disabled", "fluid", "readonly", "group", "filter", "filterPlaceHolder", "filterLocale", "overlayVisible", "tabindex", "variant", "appendTo", "dataKey", "name", "ariaLabelledBy", "displaySelectedLabel", "maxSelectedLabels", "selectionLimit", "selectedItemsLabel", "showToggleAll", "emptyFilterMessage", "emptyMessage", "resetFilterOnHide", "dropdownIcon", "chipIcon", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "showHeader", "filterBy", "scrollHeight", "lazy", "virtualScroll", "loading", "virtualScrollItemSize", "loadingIcon", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "filterMatchMode", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "autofocusFilter", "display", "autocomplete", "size", "showClear", "autofocus", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "defaultLabel", "placeholder", "options", "filterValue", "itemSize", "selectAll", "focusOnHover", "filterFields", "selectOnFocus", "autoOptionFocus"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onClear", "onPanelShow", "onPanelHide", "onLazyLoad", "onRemove", "onSelectAllChange"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: MultiselectType, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-field-multiselect',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        MultiSelectModule
+                    ],
+                    template: `
+    <ng-container *ngIf="options$ | async as options">
+      <p-multiSelect
+        [formControl]="$any(formControl)"
+        [formlyAttributes]="field"
+        [options]="options"
+        [optionLabel]="props['optionLabel'] || 'label'"
+        [optionValue]="props['optionValue'] || 'value'"
+        [placeholder]="props['placeholder'] || 'Select'"
+        [filter]="props['filter'] || true"
+        [filterBy]="props['filterBy'] || 'label'"
+        [maxSelectedLabels]="props['maxSelectedLabels'] || 2"
+        [showToggleAll]="props['showToggleAll'] || true"
+        [virtualScroll]="props['virtualScroll'] || false"
+        [display]="props['display'] || 'chip'"
+        styleClass="w-full">
+      </p-multiSelect>
+    </ng-container>
+  `
+                }]
+        }] });
+
+class DateType extends FieldType {
+    defaultOptions = {
+        props: {
+            dateFormat: 'dd-mm-yy',
+            showTime: false,
+            touchUI: false,
+            placeholder: '',
+            showButtonBar: true,
+        }
+    };
+    onDateSelect(event) {
+        this.formatAndSetDate(event);
+    }
+    onDateInput(event) {
+        const inputValue = event.target.value.trim();
+        if (this.isValidDateInput(inputValue, this.props['dateFormat'] || 'dd-mm-yy')) {
+            const parsedDate = this.parseDate(inputValue, this.props['dateFormat'] || 'dd-mm-yy');
+            if (parsedDate) {
+                this.formatAndSetDate(parsedDate);
+            }
+        }
+        else {
+            this.formControl?.setErrors({ invalidDate: true });
+        }
+    }
+    formatAndSetDate(date) {
+        if (this.formControl) {
+            const formattedDate = formatDate(date, 'dd-MM-yyyy', 'en-US');
+            this.formControl.setValue(formattedDate);
+        }
+    }
+    parseDate(value, format) {
+        const parts = value.split(/[-/]/); // Split by common delimiters
+        if (parts.length === 3) {
+            const [day, month, year] = format === 'dd-mm-yy'
+                ? [parseInt(parts[0], 10), parseInt(parts[1], 10) - 1, parseInt(parts[2], 10)]
+                : [parseInt(parts[1], 10), parseInt(parts[0], 10) - 1, parseInt(parts[2], 10)];
+            return new Date(year, month, day);
+        }
+        return null;
+    }
+    isValidDateInput(value, format) {
+        const dateRegex = format === 'dd-mm-yy'
+            ? /^\d{2}-\d{2}-\d{4}$/
+            : /^\d{2}\/\d{2}\/\d{4}$/;
+        return dateRegex.test(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: DateType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: DateType, isStandalone: true, selector: "formly-field-date", usesInheritance: true, ngImport: i0, template: `
+    <p-datepicker
+      [formControl]="$any(formControl)"
+      [formlyAttributes]="field"
+      [showIcon]="true"
+      [dateFormat]="props['dateFormat'] || 'dd-mm-yy'"
+      [showTime]="props['showTime'] || false"
+      [touchUI]="props['touchUI'] || false"
+      [placeholder]="props['placeholder'] || ''"
+      [minDate]="props['minDate']"
+      [maxDate]="props['maxDate']"
+      [showOnFocus]="false"
+      [todayButtonStyleClass]="'p-button-secondary'"
+      [clearButtonStyleClass]="'p-button-secondary'"
+      styleClass="w-full"
+      (onSelect)="onDateSelect($event)"
+      (onInput)="onDateInput($event)">
+    </p-datepicker>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: DatePickerModule }, { kind: "component", type: i3$2.DatePicker, selector: "p-datePicker, p-datepicker, p-date-picker", inputs: ["iconDisplay", "style", "styleClass", "inputStyle", "inputId", "name", "inputStyleClass", "placeholder", "ariaLabelledBy", "ariaLabel", "iconAriaLabel", "disabled", "dateFormat", "multipleSeparator", "rangeSeparator", "inline", "showOtherMonths", "selectOtherMonths", "showIcon", "fluid", "icon", "appendTo", "readonlyInput", "shortYearCutoff", "monthNavigator", "yearNavigator", "hourFormat", "timeOnly", "stepHour", "stepMinute", "stepSecond", "showSeconds", "required", "showOnFocus", "showWeek", "startWeekFromFirstDayOfYear", "showClear", "dataType", "selectionMode", "maxDateCount", "showButtonBar", "todayButtonStyleClass", "clearButtonStyleClass", "autofocus", "autoZIndex", "baseZIndex", "panelStyleClass", "panelStyle", "keepInvalid", "hideOnDateTimeSelect", "touchUI", "timeSeparator", "focusTrap", "showTransitionOptions", "hideTransitionOptions", "tabindex", "variant", "size", "minDate", "maxDate", "disabledDates", "disabledDays", "yearRange", "showTime", "responsiveOptions", "numberOfMonths", "firstDayOfWeek", "locale", "view", "defaultDate"], outputs: ["onFocus", "onBlur", "onClose", "onSelect", "onClear", "onInput", "onTodayClick", "onClearClick", "onMonthChange", "onYearChange", "onClickOutside", "onShow"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: DateType, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-field-date',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        DatePickerModule
+                    ],
+                    template: `
+    <p-datepicker
+      [formControl]="$any(formControl)"
+      [formlyAttributes]="field"
+      [showIcon]="true"
+      [dateFormat]="props['dateFormat'] || 'dd-mm-yy'"
+      [showTime]="props['showTime'] || false"
+      [touchUI]="props['touchUI'] || false"
+      [placeholder]="props['placeholder'] || ''"
+      [minDate]="props['minDate']"
+      [maxDate]="props['maxDate']"
+      [showOnFocus]="false"
+      [todayButtonStyleClass]="'p-button-secondary'"
+      [clearButtonStyleClass]="'p-button-secondary'"
+      styleClass="w-full"
+      (onSelect)="onDateSelect($event)"
+      (onInput)="onDateInput($event)">
+    </p-datepicker>
+  `
+                }]
+        }] });
+
+class CheckboxType extends FieldType {
+    defaultOptions = {
+        props: {
+            trueValue: true,
+            falseValue: false
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CheckboxType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: CheckboxType, isStandalone: true, selector: "formly-field-checkbox", usesInheritance: true, ngImport: i0, template: `
+    <div class="checkbox-container">
+      <p-checkbox
+        [formControl]="$any(formControl)"
+        [formlyAttributes]="field"
+        [binary]="!props['options']"
+        [trueValue]="props['trueValue']"
+        [falseValue]="props['falseValue']">
+        {{props['checkboxLabel'] || ''}}
+      </p-checkbox>
+    </div>
+  `, isInline: true, styles: [".checkbox-container{display:flex;align-items:center;height:40px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: CheckboxModule }, { kind: "component", type: i3$3.Checkbox, selector: "p-checkbox, p-checkBox, p-check-box", inputs: ["value", "name", "disabled", "binary", "ariaLabelledBy", "ariaLabel", "tabindex", "inputId", "style", "inputStyle", "styleClass", "inputClass", "indeterminate", "size", "formControl", "checkboxIcon", "readonly", "required", "autofocus", "trueValue", "falseValue", "variant"], outputs: ["onChange", "onFocus", "onBlur"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CheckboxType, decorators: [{
+            type: Component,
+            args: [{ selector: 'formly-field-checkbox', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        CheckboxModule
+                    ], template: `
+    <div class="checkbox-container">
+      <p-checkbox
+        [formControl]="$any(formControl)"
+        [formlyAttributes]="field"
+        [binary]="!props['options']"
+        [trueValue]="props['trueValue']"
+        [falseValue]="props['falseValue']">
+        {{props['checkboxLabel'] || ''}}
+      </p-checkbox>
+    </div>
+  `, styles: [".checkbox-container{display:flex;align-items:center;height:40px}\n"] }]
+        }] });
+
+class TextareaType extends FieldType {
+    defaultOptions = {
+        props: {
+            rows: 3,
+            cols: undefined,
+            autoResize: true,
+            placeholder: ''
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextareaType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: TextareaType, isStandalone: true, selector: "formly-field-textarea", usesInheritance: true, ngImport: i0, template: `
+    <textarea pInputTextarea
+      [formControl]="$any(formControl)"
+      [formlyAttributes]="field"
+      [rows]="props['rows'] || 3"
+      [cols]="props['cols']"
+      [autoResize]="props['autoResize']"
+      [placeholder]="props['placeholder'] || ''"
+      class="w-full">
+    </textarea>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2$1.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: Textarea }, { kind: "directive", type: i3$4.InputTextarea, selector: "[pInputTextarea]", inputs: ["autoResize", "variant", "fluid"], outputs: ["onResize"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextareaType, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-field-textarea',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        Textarea
+                    ],
+                    template: `
+    <textarea pInputTextarea
+      [formControl]="$any(formControl)"
+      [formlyAttributes]="field"
+      [rows]="props['rows'] || 3"
+      [cols]="props['cols']"
+      [autoResize]="props['autoResize']"
+      [placeholder]="props['placeholder'] || ''"
+      class="w-full">
+    </textarea>
+  `
+                }]
+        }] });
+
+class FormFieldWrapper extends FieldWrapper {
+    get errorMessage() {
+        if (!this.field.formControl?.errors) {
+            return '';
+        }
+        const firstErrorKey = Object.keys(this.field.formControl.errors)[0];
+        return this.props.validation?.messages?.[firstErrorKey] || 'This field is required';
+    }
+    get showError() {
+        if (!this.field.formControl) {
+            return false;
+        }
+        const { touched, dirty, invalid } = this.field.formControl;
+        return invalid && (touched || dirty);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormFieldWrapper, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: FormFieldWrapper, isStandalone: true, selector: "formly-wrapper-form-field", usesInheritance: true, ngImport: i0, template: `
+    <div class="field mb-4">
+      <label *ngIf="props.label" [for]="id" class="font-medium">
+        {{ props.label }}
+        <span class="required-star" *ngIf="props.required">*</span>
+        <i *ngIf="props.tooltip" 
+           class="pi pi-info-circle ml-2" 
+           [pTooltip]="props.tooltip">
+        </i>
+      </label>
+      
+      <div [class.p-input-error]="showError">
+        <ng-container #fieldComponent></ng-container>
+      </div>
+      
+      <small *ngIf="props.description" class="block mt-1">
+        {{ props.description }}
+      </small>
+      
+      <small *ngIf="showError" class="p-error block">
+        <i class="pi pi-exclamation-circle mr-2"></i>
+        {{ errorMessage }}
+      </small>
+    </div>
+  `, isInline: true, styles: [":is() .required-star{color:var(--red-500);margin-left:.25rem}:is() .p-input-error :where(input,.p-inputtext){border-color:var(--red-500)}:is() .p-input-error :where(input:enabled:focus,.p-inputtext:enabled:focus){border-color:var(--red-500);box-shadow:0 0 0 1px var(--red-500)}:is() .p-error{color:var(--red-500);margin-top:.5rem}:is() small{color:var(--text-color-secondary)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i2$2.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormFieldWrapper, decorators: [{
+            type: Component,
+            args: [{ selector: 'formly-wrapper-form-field', standalone: true, imports: [CommonModule, TooltipModule], template: `
+    <div class="field mb-4">
+      <label *ngIf="props.label" [for]="id" class="font-medium">
+        {{ props.label }}
+        <span class="required-star" *ngIf="props.required">*</span>
+        <i *ngIf="props.tooltip" 
+           class="pi pi-info-circle ml-2" 
+           [pTooltip]="props.tooltip">
+        </i>
+      </label>
+      
+      <div [class.p-input-error]="showError">
+        <ng-container #fieldComponent></ng-container>
+      </div>
+      
+      <small *ngIf="props.description" class="block mt-1">
+        {{ props.description }}
+      </small>
+      
+      <small *ngIf="showError" class="p-error block">
+        <i class="pi pi-exclamation-circle mr-2"></i>
+        {{ errorMessage }}
+      </small>
+    </div>
+  `, styles: [":is() .required-star{color:var(--red-500);margin-left:.25rem}:is() .p-input-error :where(input,.p-inputtext){border-color:var(--red-500)}:is() .p-input-error :where(input:enabled:focus,.p-inputtext:enabled:focus){border-color:var(--red-500);box-shadow:0 0 0 1px var(--red-500)}:is() .p-error{color:var(--red-500);margin-top:.5rem}:is() small{color:var(--text-color-secondary)}\n"] }]
+        }] });
+
+const FORMLY_TYPES = {
+    TEXT: 'text',
+    NUMBER: 'number',
+    DATE: 'date',
+    CHECKBOX: 'checkbox',
+    RADIO: 'radio',
+    SELECT: 'select',
+    MULTISELECT: 'multiselect',
+    TEXTAREA: 'textarea'
+};
+const FORMLY_WRAPPERS = {
+    FORM_FIELD: 'form-field'
+};
+
+class CoreFormlyModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, imports: [i2$1.FormlyModule], exports: [FormlyModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, imports: [FormlyModule.forRoot({
+                types: [
+                    { name: FORMLY_TYPES.TEXT, component: TextInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                    { name: FORMLY_TYPES.NUMBER, component: NumericInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                    { name: FORMLY_TYPES.DATE, component: DateType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                    { name: FORMLY_TYPES.CHECKBOX, component: CheckboxType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                    { name: FORMLY_TYPES.RADIO, component: RadioType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                    { name: FORMLY_TYPES.SELECT, component: SelectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                    { name: FORMLY_TYPES.MULTISELECT, component: MultiselectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                    { name: FORMLY_TYPES.TEXTAREA, component: TextareaType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] }, // Added textarea type
+                ],
+                wrappers: [
+                    { name: FORMLY_WRAPPERS.FORM_FIELD, component: FormFieldWrapper }
+                ]
+            }), FormlyModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        FormlyModule.forRoot({
+                            types: [
+                                { name: FORMLY_TYPES.TEXT, component: TextInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                                { name: FORMLY_TYPES.NUMBER, component: NumericInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                                { name: FORMLY_TYPES.DATE, component: DateType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                                { name: FORMLY_TYPES.CHECKBOX, component: CheckboxType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                                { name: FORMLY_TYPES.RADIO, component: RadioType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                                { name: FORMLY_TYPES.SELECT, component: SelectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                                { name: FORMLY_TYPES.MULTISELECT, component: MultiselectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
+                                { name: FORMLY_TYPES.TEXTAREA, component: TextareaType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] }, // Added textarea type
+                            ],
+                            wrappers: [
+                                { name: FORMLY_WRAPPERS.FORM_FIELD, component: FormFieldWrapper }
+                            ]
+                        })
+                    ],
+                    exports: [FormlyModule]
+                }]
+        }] });
+
+/**
+ * Base component for all page components in the application.
+ * Provides common functionality like loading state and message display.
+ */
+class BasePageComponent {
+    utilsService;
+    notificationService;
+    loading = false;
+    constructor(utilsService, notificationService) {
+        this.utilsService = utilsService;
+        this.notificationService = notificationService;
+    }
+    /**
+     * Display an error message to the user
+     * @param detail The error message to display
+     */
+    showError(detail) {
+        this.notificationService.showError(detail);
+    }
+    /**
+     * Display a success message to the user
+     * @param detail The success message to display
+     */
+    showSuccess(detail) {
+        this.notificationService.showSuccess(detail);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BasePageComponent, deps: [{ token: UtilsService }, { token: NotificationService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.6", type: BasePageComponent, isStandalone: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BasePageComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: UtilsService }, { type: NotificationService }] });
+
+class BaseFormComponent extends BasePageComponent {
+    route;
+    router;
+    notificationService;
+    utilsService;
+    formlyConfigService;
+    destroyed$ = new Subject();
+    state = {
+        form: new FormGroup({}),
+        fields: [],
+        isNew: true,
+        mode: AppConstants.PAGE_MODE.CREATE,
+        currentData: {},
+        originalData: null,
+        hasChanges: false,
+        loading: false,
+        context: ComponentContext.STANDALONE
+    };
+    constructor(route, router, notificationService, utilsService, formlyConfigService) {
+        super(utilsService, notificationService);
+        this.route = route;
+        this.router = router;
+        this.notificationService = notificationService;
+        this.utilsService = utilsService;
+        this.formlyConfigService = formlyConfigService;
+    }
+    ngOnInit() {
+        this.initializeForm()
+            .pipe(switchMap(() => this.loadFormData()), takeUntil(this.destroyed$))
+            .subscribe({
+            next: () => this.onFormReady(),
+            error: error => this.handleInitError(error)
+        });
+    }
+    initializeForm() {
+        return this.route.queryParams.pipe(take(1), map(params => {
+            this.initializeFormMode(params[AppConstants.FORM.MODE]);
+            this.setupFormState();
+            this.initializeFormSubscriptions();
+        }));
+    }
+    loadFormData() {
+        return this.route.queryParams.pipe(take(1), mergeMap(params => {
+            const state = this.getRouterState();
+            if (this.state.mode === AppConstants.PAGE_MODE.CREATE) {
+                return of(void 0);
+            }
+            if (state?.formData) {
+                this.updateFormState(state.formData);
+                return of(void 0);
+            }
+            const uuid = params[AppConstants.FORM.UUID];
+            if (!uuid) {
+                throw new Error(`UUID is required for ${this.state.mode} mode`);
+            }
+            return this.getEntityOperations().getById(uuid)
+                .pipe(tap(data => this.updateFormState(data)), map(() => void 0));
+        }));
+    }
+    getRouterState() {
+        return {
+            ...this.router.getCurrentNavigation()?.extras?.state,
+            ...window.history.state,
+            ...this.route.snapshot.data
+        };
+    }
+    initializeFormSubscriptions() {
+        this.state.form.valueChanges
+            .pipe(debounceTime(300), distinctUntilChanged(), takeUntil(this.destroyed$))
+            .subscribe(() => {
+            this.updateCurrentData();
+            this.checkFormChanges();
+        });
+        // Check for context in router state
+        const routerState = window.history.state;
+        if (routerState?.context) {
+            this.state.context = routerState.context;
+            console.log('[BaseFormComponent] Context set from router state:', this.state.context);
+        }
+    }
+    set formData(data) {
+        console.log('[BaseFormComponent] Form data input changed:', data);
+        if (data) {
+            // Reset form with new data
+            this.state.fields = this.getFormlyFieldConfig();
+            this.state.form.reset();
+            this.state.currentData = { ...data };
+            this.state.originalData = data;
+            this.state.isNew = false;
+            // Update form values after reset
+            this.state.form.patchValue(data);
+            console.log('[BaseFormComponent] Form state updated:', {
+                fields: this.state.fields,
+                formValue: this.state.form.value,
+                currentData: this.state.currentData
+            });
+        }
+    }
+    updateCurrentData() {
+        this.state.currentData = {
+            ...this.state.form.value,
+            uuid: this.state.originalData?.uuid
+        };
+    }
+    checkFormChanges() {
+        this.state.hasChanges = this.hasFormChanges(this.state.currentData);
+    }
+    updateFormState(data) {
+        this.state = {
+            ...this.state,
+            currentData: { ...data },
+            originalData: data,
+            isNew: false,
+            loading: false
+        };
+        this.state.form.patchValue(data, { emitEvent: false });
+    }
+    handleInitError(error) {
+        console.error('Form initialization error:', error);
+        this.notificationService.showError(AppMessages.FORM.ERROR.INIT);
+        this.state.loading = false;
+    }
+    handleLoadError(error) {
+        const entityName = this.getEntityName();
+        console.error(`Error loading ${entityName}:`, error);
+        this.notificationService.showError(`${AppMessages.FORM.ERROR.LOAD} ${entityName}`);
+        this.state.loading = false;
+    }
+    patchFormData(data) {
+        this.formData = data;
+    }
+    initializeFormMode(routeMode) {
+        if (!routeMode) {
+            this.state.mode = AppConstants.PAGE_MODE.CREATE;
+        }
+        else if (this.isValidPageMode(routeMode)) {
+            this.state.mode = routeMode;
+        }
+        else {
+            throw new Error(`Invalid page mode: ${routeMode}`);
+        }
+    }
+    setupFormState() {
+        this.state.fields = this.getFormlyFieldConfig();
+        if (this.state.mode === AppConstants.PAGE_MODE.CREATE) {
+            this.state.isNew = true;
+            this.state.loading = false;
+            this.state.originalData = null;
+        }
+        if (this.state.mode === AppConstants.PAGE_MODE.VIEW) {
+            this.state.form.disable();
+        }
+    }
+    onFormReady() {
+        console.log('[BaseFormComponent] Form initialized successfully');
+    }
+    getFormlyFieldConfig() {
+        return this.formlyConfigService.getFormConfig(this.getJsonFields(), this.state.mode, this.getDropdownOptions());
+    }
+    onSubmitRoute() {
+        return [`/${this.getEntityName().toLowerCase()}s`];
+    }
+    getEntityOperations() {
+        const entityService = this.getEntityService();
+        return {
+            create: (data) => entityService.create(data),
+            update: (uuid, data) => entityService.update(uuid, { ...data, uuid }),
+            getById: (uuid) => entityService.getById(uuid)
+        };
+    }
+    onSubmit() {
+        if (!this.validateSubmission()) {
+            return;
+        }
+        this.state.loading = true;
+        const operation$ = this.getSubmitOperation();
+        operation$
+            .pipe(finalize$1(() => this.state.loading = false), takeUntil(this.destroyed$))
+            .subscribe({
+            next: () => this.handleSubmitSuccess(),
+            error: error => this.handleSubmitError(error)
+        });
+    }
+    validateSubmission() {
+        if (!this.state.form.valid) {
+            this.notificationService.showError('Please check form errors');
+            return false;
+        }
+        if (!this.state.hasChanges && !this.state.isNew) {
+            this.notificationService.showSuccess('No changes to save');
+            return false;
+        }
+        if (!this.state.currentData || Object.keys(this.state.currentData).length === 0) {
+            this.notificationService.showError('No data to save');
+            return false;
+        }
+        return true;
+    }
+    getSubmitOperation() {
+        const formData = this.state.currentData;
+        const operations = this.getEntityOperations();
+        return this.state.isNew
+            ? operations.create(formData)
+            : operations.update(this.state.originalData.uuid, formData);
+    }
+    handleSubmitSuccess() {
+        const entityName = this.getEntityName();
+        this.notificationService.showSuccess(`${entityName} ${AppMessages.FORM.SUCCESS.SAVE}`);
+        this.router.navigate(this.onSubmitRoute());
+    }
+    handleSubmitError(error) {
+        const entityName = this.getEntityName();
+        const errorMessage = error.error?.message || `${AppMessages.FORM.ERROR.SAVE} ${entityName}`;
+        this.showError(errorMessage);
+    }
+    hasFormChanges(currentData) {
+        if (!this.state.originalData || this.state.isNew) {
+            return true;
+        }
+        console.log('[BaseFormComponent] Checking for changes:', {
+            currentData,
+            originalData: this.state.originalData
+        });
+        const hasChanges = Object.keys(currentData).some(key => {
+            const currentValue = currentData[key];
+            const originalValue = this.state.originalData[key];
+            const changed = currentValue !== originalValue;
+            if (changed) {
+                console.log(`[BaseFormComponent] Field '${key}' changed:`, {
+                    from: originalValue,
+                    to: currentValue
+                });
+            }
+            return changed;
+        });
+        console.log('[BaseFormComponent] Changes detected:', hasChanges);
+        return hasChanges;
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    isValidPageMode(mode) {
+        return Object.values(AppConstants.PAGE_MODE).includes(mode);
+    }
+    getDropdownOptions() {
+        return {};
+    }
+    /**
+     * Checks if the component is running in a specific context
+     * @param contextType The context type to check against
+     */
+    isInContext(contextType) {
+        return this.state.context === contextType;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseFormComponent, deps: [{ token: i1$1.ActivatedRoute }, { token: i1$1.Router }, { token: NotificationService }, { token: UtilsService }, { token: FormlyConfigService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: BaseFormComponent, isStandalone: true, selector: "ng-component", inputs: { formData: "formData" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseFormComponent });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseFormComponent, decorators: [{
+            type: Injectable
+        }, {
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: () => [{ type: i1$1.ActivatedRoute }, { type: i1$1.Router }, { type: NotificationService }, { type: UtilsService }, { type: FormlyConfigService }], propDecorators: { formData: [{
+                type: Input
+            }] } });
+
+/**
+ * Base component for all table components in the application.
+ * Provides common functionality for table operations like loading data,
+ * pagination, sorting, and filtering.
+ */
+class BaseTableComponent extends BasePageComponent {
+    utilsService;
+    notificationService;
+    table;
+    items = [];
     rows = 10;
     totalRecords = 0;
     filters = [];
     subscriptions = [];
-    constructor(router, notificationService, utilsService, confirmationService) {
+    constructor(utilsService, notificationService) {
         super(utilsService, notificationService);
-        this.router = router;
-        this.notificationService = notificationService;
         this.utilsService = utilsService;
-        this.confirmationService = confirmationService;
+        this.notificationService = notificationService;
     }
     /**
-     * Initialize the component, subscribe to loading state if available,
-     * and load initial data.
+     * Initialize the component and load initial data
      */
     ngOnInit() {
         // Subscribe to loading state if available
@@ -1179,16 +2088,51 @@ class BaseListPageComponent extends BasePageComponent {
      * Load data with pagination and sorting
      * @param event The lazy load event from PrimeNG table
      */
-    /**
-     * Convert PrimeNG filter format to backend format
-     * @param filters The PrimeNG filters object
-     * @returns Converted filters object for backend
-     */
-    /**
-     * Convert PrimeNG filter format to backend format
-     * @param filters The PrimeNG filters object
-     * @returns Converted filters object for backend
-     */
+    loadData(event) {
+        console.log('LoadData called with event:', event);
+        this.loading = true;
+        // Create page request with default values
+        const pageRequest = {
+            page: 0,
+            size: 10,
+            sorts: [],
+            filters: []
+        };
+        if (event) {
+            // Handle pagination
+            if (event.first !== undefined && event.rows) {
+                pageRequest.page = Math.floor(event.first / event.rows);
+                pageRequest.size = event.rows;
+            }
+            // Handle sorting
+            if (event.sortField) {
+                pageRequest.sorts = [{
+                        field: Array.isArray(event.sortField) ? event.sortField[0] : event.sortField,
+                        direction: event.sortOrder === 1 ? 'asc' : 'desc'
+                    }];
+            }
+            // Handle filtering
+            if (event.filters) {
+                const convertedFilters = this.convertFilters(event.filters);
+                console.log('Converted filters:', convertedFilters);
+                pageRequest.filters = convertedFilters;
+            }
+        }
+        console.log('Sending page request:', pageRequest);
+        this.getEntityService().getAll(pageRequest)
+            .pipe(finalize$1(() => this.loading = false))
+            .subscribe({
+            next: (response) => {
+                this.items = [...response.content];
+                this.totalRecords = response.totalElements;
+                this.rows = response.pageable.pageSize;
+            },
+            error: (error) => {
+                console.error('Failed to load data:', error);
+                this.showError(`Failed to load data`);
+            }
+        });
+    }
     /**
      * Convert PrimeNG filters to backend format with proper operator mapping
      */
@@ -1260,136 +2204,6 @@ class BaseListPageComponent extends BasePageComponent {
         };
         return operatorMap[operator] || 'EQUALS'; // Default to EQUALS if operator not found
     }
-    loadData(event) {
-        console.log('LoadData called with event:', event);
-        this.loading = true;
-        // Create page request with default values
-        const pageRequest = {
-            page: 0,
-            size: 10,
-            sorts: [],
-            filters: []
-        };
-        if (event) {
-            // Handle pagination
-            if (event.first !== undefined && event.rows) {
-                pageRequest.page = Math.floor(event.first / event.rows);
-                pageRequest.size = event.rows;
-            }
-            // Handle sorting
-            if (event.sortField) {
-                pageRequest.sorts = [{
-                        field: Array.isArray(event.sortField) ? event.sortField[0] : event.sortField,
-                        direction: event.sortOrder === 1 ? 'asc' : 'desc'
-                    }];
-            }
-            // Handle filtering
-            if (event.filters) {
-                const convertedFilters = this.convertFilters(event.filters);
-                console.log('Converted filters:', convertedFilters);
-                pageRequest.filters = convertedFilters;
-            }
-        }
-        console.log('Sending page request:', pageRequest);
-        this.getEntityService().getAll(pageRequest)
-            .pipe(finalize$1(() => this.loading = false))
-            .subscribe({
-            next: (response) => {
-                this.items = [...response.content];
-                this.totalRecords = response.page.totalElements;
-            },
-            error: (error) => {
-                console.error('Failed to load data:', error);
-                this.showError(`${AppMessages.LIST.ERROR.LOAD} ${this.getEntityName()}`);
-            }
-        });
-    }
-    /**
-     * Navigate to create a new entity
-     */
-    onCreate() {
-        // Navigate to the form route and pass the mode as a query parameter
-        this.navigateTo([this.getFormRoute()], { [AppConstants.FORM.MODE]: AppConstants.PAGE_MODE.CREATE });
-    }
-    /**
-     * Navigate to view an entity
-     * @param item The entity to view
-     */
-    onView(item) {
-        if (!this.validateItemUuid(item, 'view'))
-            return;
-        // Correct: Navigate to form route, pass mode and uuid as query params
-        this.navigateTo([this.getFormRoute()], {
-            [AppConstants.FORM.MODE]: AppConstants.PAGE_MODE.VIEW,
-            [AppConstants.FORM.UUID]: item.uuid
-        });
-    }
-    /**
-     * Navigate to edit an entity
-     * @param item The entity to edit
-     */
-    onEdit(item) {
-        if (!this.validateItemUuid(item, 'edit'))
-            return;
-        // Correct: Navigate to form route, pass mode and uuid as query params
-        this.navigateTo([this.getFormRoute()], {
-            [AppConstants.FORM.MODE]: AppConstants.PAGE_MODE.EDIT,
-            [AppConstants.FORM.UUID]: item.uuid
-        });
-    }
-    /**
-     * Navigate to a route with error handling
-     * @param path The route path
-     * @param matrixParams Optional matrix parameters
-     */
-    navigateTo(path, matrixParams) {
-        this.router.navigate(path, { queryParams: matrixParams })
-            .catch(error => {
-            console.error('Navigation error:', error);
-            this.showError(AppMessages.LIST.ERROR.NAVIGATION);
-        });
-    }
-    /**
-     * Delete an entity with confirmation
-     * @param item The entity to delete
-     */
-    onDelete(item) {
-        if (!this.validateItemUuid(item, 'delete'))
-            return;
-        this.confirmationService.confirm({
-            message: `Are you sure you want to delete this ${this.getEntityName()}?`,
-            header: 'Confirm Deletion',
-            icon: 'pi pi-exclamation-triangle',
-            accept: () => {
-                this.actionLoading = true;
-                this.getEntityService().delete(item.uuid)
-                    .pipe(finalize$1(() => this.actionLoading = false))
-                    .subscribe({
-                    next: () => {
-                        this.showSuccess(`${this.getEntityName()} ${AppMessages.LIST.SUCCESS.DELETE}`);
-                        this.loadData();
-                    },
-                    error: (error) => {
-                        console.error('Delete failed:', error);
-                        this.showError(`${AppMessages.LIST.ERROR.DELETE} ${this.getEntityName()}`);
-                    }
-                });
-            }
-        });
-    }
-    /**
-     * Validate that an entity has a UUID
-     * @param item The entity to validate
-     * @param action The action being performed
-     * @returns true if valid, false otherwise
-     */
-    validateItemUuid(item, action) {
-        if (!item?.uuid) {
-            this.showError(`${AppMessages.LIST.ERROR.INVALID_ID} ${action}`);
-            return false;
-        }
-        return true;
-    }
     /**
      * Get an observable for loading state from the entity service
      * @returns An observable of loading state if available, null otherwise
@@ -1398,1002 +2212,782 @@ class BaseListPageComponent extends BasePageComponent {
         const service = this.getEntityService();
         return service.loading$ || null;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseListPageComponent, deps: [{ token: i1$2.Router }, { token: NotificationService }, { token: UtilsService }, { token: i1.ConfirmationService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.6", type: BaseListPageComponent, isStandalone: true, viewQueries: [{ propertyName: "table", first: true, predicate: ["dt"], descendants: true }], usesInheritance: true, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTableComponent, deps: [{ token: UtilsService }, { token: NotificationService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.6", type: BaseTableComponent, isStandalone: true, viewQueries: [{ propertyName: "table", first: true, predicate: ["dt"], descendants: true }], usesInheritance: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseListPageComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTableComponent, decorators: [{
             type: Directive
-        }], ctorParameters: () => [{ type: i1$2.Router }, { type: NotificationService }, { type: UtilsService }, { type: i1.ConfirmationService }], propDecorators: { table: [{
+        }], ctorParameters: () => [{ type: UtilsService }, { type: NotificationService }], propDecorators: { table: [{
                 type: ViewChild,
                 args: ['dt']
             }] } });
 
-class BaseTabbedFormComponent extends BasePageComponent {
-    route;
+/**
+ * Base component for all list page components in the application.
+ * Provides common functionality for list operations like CRUD operations
+ * while inheriting table functionality from BaseTableComponent.
+ */
+class BaseListPageComponent extends BaseTableComponent {
     router;
     notificationService;
     utilsService;
-    // Tab specific properties
-    activeTab = '';
-    tabs = [];
-    formType = '';
-    // Form properties
-    isNew = true;
-    mode = AppConstants.PAGE_MODE.CREATE;
-    currentFormData;
-    originalFormData = null;
-    hasChanges = false;
-    // debug method removed
-    constructor(route, router, notificationService, utilsService) {
+    confirmationService;
+    actionLoading = false;
+    constructor(router, notificationService, utilsService, confirmationService) {
         super(utilsService, notificationService);
-        this.route = route;
         this.router = router;
         this.notificationService = notificationService;
         this.utilsService = utilsService;
+        this.confirmationService = confirmationService;
     }
-    ngOnInit() {
-        try {
-            // Initialize tabs
-            this.tabs = this.getTabs();
-            this.activeTab = this.tabs[0]?.value || '';
-            // Initialize form using query params
-            this.route.queryParams.pipe(take(1)).subscribe({
-                next: params => this.initializeForm(params),
-                error: error => {
-                    console.error('Error initializing form:', error);
-                    this.showError(AppMessages.FORM.ERROR.INIT);
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error in ngOnInit:', error);
-            this.showError(AppMessages.FORM.ERROR.INIT);
-        }
-    }
-    initializeFormData() {
-        console.log('[BaseTabbedFormComponent] Initializing form data');
-        console.log('[BaseTabbedFormComponent] Current mode:', this.mode);
-        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
-            console.log('[BaseTabbedFormComponent] Create mode, using defaults');
-            this.loadDefaultTab();
-            return;
-        }
-        const state = {
-            ...this.router.getCurrentNavigation()?.extras?.state,
-            ...window.history.state
-        };
-        console.log('[BaseTabbedFormComponent] Combined state:', state);
-        if (state?.formData) {
-            console.log('[BaseTabbedFormComponent] Found form data in state:', state.formData);
-            this.patchFormData(state.formData);
-            this.loadDefaultTab();
-        }
-        else {
-            console.log('[BaseTabbedFormComponent] No form data, loading from UUID');
-            this.loadFromUuid();
-        }
-    }
-    loadFromUuid() {
-        // Flatten nested subscriptions using RxJS operators
-        this.route.queryParams.pipe(take(1), map((params) => {
-            const uuid = params[AppConstants.FORM.UUID];
-            if (!uuid) {
-                throw new Error(`UUID is required for ${this.mode} mode when no formData is provided`);
-            }
-            return uuid;
-        })).subscribe({
-            next: (uuid) => this.loadEntity(uuid),
-            error: (error) => {
-                console.error('Error loading UUID:', error);
-                this.showError(`${AppMessages.FORM.ERROR.LOAD} UUID`);
-            }
-        });
-    }
-    initializeForm(params) {
-        const routeMode = params[AppConstants.FORM.MODE];
-        try {
-            this.initializeFormMode(routeMode);
-            this.setupFormState();
-            if (this.formType === TabbedFormType.LIST) {
-                this.initializeListForm(params);
-            }
-            else {
-                // Existing logic for STANDARD form type
-                this.initializeFormData();
-            }
-        }
-        catch (error) {
-            console.error('Error initializing form:', error);
-            this.showError(`${AppMessages.FORM.ERROR.INIT}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    patchFormData(data) {
-        if (data) {
-            this.currentFormData = { ...data };
-            this.originalFormData = { ...data }; // Create a deep copy to avoid reference issues
-            this.isNew = false;
-        }
-    }
-    initializeFormMode(routeMode) {
-        if (!routeMode) {
-            this.mode = AppConstants.PAGE_MODE.CREATE;
-            return;
-        }
-        // Validate mode more explicitly
-        if (!this.isValidPageMode(routeMode)) {
-            const validModes = Object.values(AppConstants.PAGE_MODE).join(', ');
-            throw new Error(`Invalid page mode: ${routeMode}. Valid modes are: ${validModes}`);
-        }
-        this.mode = routeMode;
-    }
-    setupFormState() {
-        console.log('[BaseTabbedFormComponent] Setting up form state, mode:', this.mode);
-        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
-            console.log('[BaseTabbedFormComponent] Create mode setup');
-            this.isNew = true;
-            this.loading = false;
-            this.originalFormData = null;
-        }
-    }
-    loadEntity(uuid) {
-        this.loading = true;
-        this.isNew = false;
-        const entityName = this.getEntityName();
-        this.getEntityService().getById(uuid).subscribe({
-            next: (data) => {
-                this.originalFormData = data;
-                this.currentFormData = { ...data };
-                this.loading = false;
-                console.log('[BaseTabbedFormComponent] Original data loaded:', this.originalFormData);
-                console.log('[BaseTabbedFormComponent] Form data updated:', this.currentFormData);
-                this.loadDefaultTab();
-            },
-            error: (error) => {
-                console.log('[BaseTabbedFormComponent] Error loading entity:', error);
-                this.showError(`${AppMessages.FORM.ERROR.LOAD} ${entityName}`);
-                this.loading = false;
-            }
-        });
-    }
-    findTabByValue(value) {
-        return this.tabs.find(tab => tab.value === value);
-    }
-    loadDefaultTab() {
-        console.log('[BaseTabbedFormComponent] Loading default tab');
-        const defaultTab = this.tabs.find(tab => tab.isParentModel) || this.tabs[0];
-        if (!defaultTab)
-            return;
-        if (this.formType === TabbedFormType.LIST) {
-            const state = this.router.getCurrentNavigation()?.extras?.state || window.history.state;
-            const formDataList = state?.formDataList || [];
-            const selectedData = formDataList.find((data) => data.uuid === defaultTab.value);
-            if (selectedData) {
-                this.currentFormData = selectedData;
-                this.originalFormData = { ...selectedData };
-                this.patchFormData(selectedData);
-            }
-            this.router.navigate([defaultTab.value], {
-                relativeTo: this.route,
-                state: {
-                    formData: selectedData,
-                    formDataList: formDataList,
-                    context: ComponentContext.TABBED
-                }
-            });
-        }
-        else if (this.formType === TabbedFormType.STANDARD) {
-            // For STANDARD type, just navigate to the tab route with the parent form data
-            this.router.navigate([defaultTab.value], {
-                relativeTo: this.route,
-                queryParamsHandling: 'preserve', // Keep existing query params (mode & uuid)
-                state: {
-                    formData: defaultTab.isParentModel ? this.currentFormData : null,
-                    parentFormData: this.currentFormData, // Pass the parent form data for child forms
-                    context: ComponentContext.TABBED
-                }
-            });
-        }
-        else {
-            // Default behavior for other form types
-            this.router.navigate([defaultTab.value], {
-                relativeTo: this.route,
-                queryParamsHandling: 'preserve', // Keep existing query params (mode & uuid)
-                state: {
-                    formData: this.currentFormData,
-                    context: ComponentContext.TABBED
-                }
-            });
-        }
-    }
-    getTabFormData(tabConfig) {
-        if (!tabConfig)
-            return null;
-        if (tabConfig.isParentModel) {
-            return this.currentFormData;
-        }
-        const fieldName = this.utilsService.toCamelCase(tabConfig.value);
-        // Use type assertion since we know this is a valid field
-        return this.currentFormData[fieldName];
+    /**
+     * Navigate to create a new entity
+     */
+    onCreate() {
+        // Navigate to the form route and pass the mode as a query parameter
+        this.navigateTo([this.getFormRoute()], { [AppConstants.FORM.MODE]: AppConstants.PAGE_MODE.CREATE });
     }
-    initializeListForm(params) {
-        const state = this.router.getCurrentNavigation()?.extras?.state || window.history.state;
-        const formDataList = state?.formDataList;
-        if (!formDataList?.length) {
-            throw new Error('formDataList is required in state for LIST type');
-        }
-        this.tabs = this.createTabsFromFormDataList(formDataList);
-        // Select the first tab by default
-        this.activeTab = this.tabs[0].value;
-        // Set current form data from the first item in the list
-        this.currentFormData = formDataList[0];
-        this.originalFormData = formDataList[0];
-        // Navigate to the first tab
-        this.router.navigate([this.activeTab], {
-            relativeTo: this.route,
-            state: {
-                formData: this.currentFormData,
-                formDataList: formDataList,
-                context: ComponentContext.TABBED
-            }
+    /**
+     * Navigate to view an entity
+     * @param item The entity to view
+     */
+    onView(item) {
+        if (!this.validateItemUuid(item, 'view'))
+            return;
+        // Navigate to form route, pass mode and uuid as query params
+        this.navigateTo([this.getFormRoute()], {
+            [AppConstants.FORM.MODE]: AppConstants.PAGE_MODE.VIEW,
+            [AppConstants.FORM.UUID]: item.uuid
         });
-        // Ensure the form data is updated after navigation
-        this.patchFormData(this.currentFormData);
     }
-    createTabsFromFormDataList(formDataList) {
-        return formDataList.map((data) => ({
-            value: data.uuid,
-            title: this.getTabTitle(data),
-            isParentModel: true
-        }));
+    /**
+     * Navigate to edit an entity
+     * @param item The entity to edit
+     */
+    onEdit(item) {
+        if (!this.validateItemUuid(item, 'edit'))
+            return;
+        // Navigate to form route, pass mode and uuid as query params
+        this.navigateTo([this.getFormRoute()], {
+            [AppConstants.FORM.MODE]: AppConstants.PAGE_MODE.EDIT,
+            [AppConstants.FORM.UUID]: item.uuid
+        });
     }
-    onTabChange(value) {
-        const tabConfig = this.findTabByValue(value);
-        if (!tabConfig) {
-            console.warn(`Tab not found: ${value}`);
+    /**
+     * Delete an entity with confirmation
+     * @param item The entity to delete
+     */
+    onDelete(item) {
+        if (!this.validateItemUuid(item, 'delete'))
             return;
-        }
-        this.activeTab = tabConfig.value;
-        if (this.formType === TabbedFormType.LIST) {
-            const state = this.router.getCurrentNavigation()?.extras?.state || window.history.state;
-            const formDataList = state?.formDataList || [];
-            const selectedData = formDataList.find((data) => data.uuid === value);
-            if (selectedData) {
-                // Update current form data
-                this.currentFormData = selectedData;
-                this.originalFormData = { ...selectedData };
-                this.patchFormData(selectedData);
-                this.router.navigate([value], {
-                    relativeTo: this.route,
-                    state: {
-                        formData: selectedData,
-                        formDataList: formDataList,
-                        context: ComponentContext.TABBED
+        this.confirmationService.confirm({
+            message: `Are you sure you want to delete this ${this.getEntityName()}?`,
+            header: 'Confirm Deletion',
+            icon: 'pi pi-exclamation-triangle',
+            accept: () => {
+                this.actionLoading = true;
+                this.getEntityService().delete(item.uuid)
+                    .pipe(finalize$1(() => this.actionLoading = false))
+                    .subscribe({
+                    next: () => {
+                        this.showSuccess(`${this.getEntityName()} ${AppMessages.LIST.SUCCESS.DELETE}`);
+                        this.loadData();
+                    },
+                    error: (error) => {
+                        console.error('Delete failed:', error);
+                        this.showError(`${AppMessages.LIST.ERROR.DELETE} ${this.getEntityName()}`);
                     }
                 });
             }
-        }
-        else if (this.formType === TabbedFormType.STANDARD) {
-            // For STANDARD type, navigate to the tab route with the parent form data
-            this.router.navigate([this.activeTab], {
-                relativeTo: this.route,
-                queryParamsHandling: 'preserve',
-                state: {
-                    formData: tabConfig.isParentModel ? this.currentFormData : null,
-                    parentFormData: this.currentFormData,
-                    context: ComponentContext.TABBED
-                }
-            });
-        }
-        else {
-            // Default behavior for other form types
-            const formData = this.getTabFormData(tabConfig);
-            this.router.navigate([this.activeTab], {
-                relativeTo: this.route,
-                queryParamsHandling: 'preserve',
-                state: {
-                    formData,
-                    context: ComponentContext.TABBED
-                }
-            });
-        }
-    }
-    hasFormChanges(currentData) {
-        // For new forms or no original data, consider it changed
-        if (this.isNew || !this.originalFormData) {
-            return true;
-        }
-        // Deep comparison of objects
-        return !this.isEqual(currentData, this.originalFormData);
-    }
-    isEqual(obj1, obj2) {
-        if (obj1 === obj2)
-            return true;
-        if (typeof obj1 !== 'object' || obj1 === null ||
-            typeof obj2 !== 'object' || obj2 === null)
-            return false;
-        const keys1 = Object.keys(obj1);
-        const keys2 = Object.keys(obj2);
-        if (keys1.length !== keys2.length)
-            return false;
-        return keys1.every(key => Object.prototype.hasOwnProperty.call(obj2, key) &&
-            this.isEqual(obj1[key], obj2[key]));
-    }
-    isValidPageMode(mode) {
-        return Object.values(AppConstants.PAGE_MODE).includes(mode);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTabbedFormComponent, deps: [{ token: i1$2.ActivatedRoute }, { token: i1$2.Router }, { token: NotificationService }, { token: UtilsService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: BaseTabbedFormComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTabbedFormComponent });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTabbedFormComponent, decorators: [{
-            type: Injectable
-        }, {
-            type: Component,
-            args: [{
-                    template: ''
-                }]
-        }], ctorParameters: () => [{ type: i1$2.ActivatedRoute }, { type: i1$2.Router }, { type: NotificationService }, { type: UtilsService }] });
-
-class IndianDatePipe {
-    datePipe;
-    constructor(datePipe) {
-        this.datePipe = datePipe;
-    }
-    transform(value, format = 'default') {
-        if (!value)
-            return null;
-        // First validate dd-MM-yyyy format
-        const dateRegex = /^(0[1-9]|[12][0-9]|3[01])-(0[1-9]|1[0-2])-\d{4}$/;
-        if (!dateRegex.test(value)) {
-            throw new Error(`Invalid date format: ${value}. Expected format: dd-MM-yyyy`);
-        }
-        // Validate real date
-        const [day, month, year] = value.split('-').map(Number);
-        const date = new Date(year, month - 1, day);
-        if (date.getFullYear() !== year ||
-            date.getMonth() !== month - 1 ||
-            date.getDate() !== day) {
-            throw new Error(`Invalid date: ${value}`);
-        }
-        // Apply requested format
-        switch (format) {
-            case 'short':
-                // Pad with leading zeros for consistent format
-                const paddedDay = day.toString().padStart(2, '0');
-                const paddedMonth = month.toString().padStart(2, '0');
-                return `${paddedDay}-${paddedMonth}-${year}`; // 10-03-2025
-            case 'medium':
-                return this.datePipe.transform(date, 'dd MMM yyyy'); // 10 Jan 2019
-            default:
-                return value; // original dd-MM-yyyy
-        }
+        });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: IndianDatePipe, deps: [{ token: i1$3.DatePipe }], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.6", ngImport: i0, type: IndianDatePipe, isStandalone: true, name: "indianDate" });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: IndianDatePipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'indianDate',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1$3.DatePipe }] });
-
-class TextInputType extends FieldType {
-    defaultOptions = {
-        props: {
-            type: 'text',
-            placeholder: ''
-        }
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextInputType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: TextInputType, isStandalone: true, selector: "formly-field-text-input", usesInheritance: true, ngImport: i0, template: `
-    <input pInputText
-           [type]="props['type'] || 'text'"
-           [formControl]="$any(formControl)"
-           [formlyAttributes]="field"
-           [placeholder]="props['placeholder'] || ''"
-           [attr.aria-label]="props['label'] || props['placeholder'] || ''"
-           class="w-full"/>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i3.InputText, selector: "[pInputText]", inputs: ["variant", "fluid", "pSize"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextInputType, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'formly-field-text-input',
-                    standalone: true,
-                    imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        InputTextModule
-                    ],
-                    template: `
-    <input pInputText
-           [type]="props['type'] || 'text'"
-           [formControl]="$any(formControl)"
-           [formlyAttributes]="field"
-           [placeholder]="props['placeholder'] || ''"
-           [attr.aria-label]="props['label'] || props['placeholder'] || ''"
-           class="w-full"/>
-  `
-                }]
-        }] });
-
-class SelectType extends FieldType {
-    get options$() {
-        const options = this.props['options'];
-        return isObservable(options) ? options : of(options || []);
+    /**
+     * Navigate to a route with error handling
+     * @param path The route path
+     * @param matrixParams Optional matrix parameters
+     */
+    navigateTo(path, matrixParams) {
+        this.router.navigate(path, { queryParams: matrixParams })
+            .catch(error => {
+            console.error('Navigation error:', error);
+            this.showError(AppMessages.LIST.ERROR.NAVIGATION);
+        });
     }
-    defaultOptions = {
-        props: {
-            options: [],
-            optionLabel: 'label',
-            optionValue: 'value',
-            placeholder: 'Select',
-            showClear: false,
-            filter: false,
-            virtualScroll: false
-        }
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: SelectType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: SelectType, isStandalone: true, selector: "formly-field-select", usesInheritance: true, ngImport: i0, template: `
-    <ng-container *ngIf="options$ | async as options">
-      <p-select
-        [formControl]="$any(formControl)"
-        [formlyAttributes]="field"
-        [options]="options"
-        [virtualScroll]="false"
-        [showClear]="false"
-        [placeholder]="props['placeholder'] || 'Select'"
-        styleClass="w-full">
-      </p-select>
-    </ng-container>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1$3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: SelectModule }, { kind: "component", type: i4.Select, selector: "p-select", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "size", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "fluid", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: SelectType, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'formly-field-select',
-                    standalone: true,
-                    imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        SelectModule
-                    ],
-                    template: `
-    <ng-container *ngIf="options$ | async as options">
-      <p-select
-        [formControl]="$any(formControl)"
-        [formlyAttributes]="field"
-        [options]="options"
-        [virtualScroll]="false"
-        [showClear]="false"
-        [placeholder]="props['placeholder'] || 'Select'"
-        styleClass="w-full">
-      </p-select>
-    </ng-container>
-  `
-                }]
-        }] });
-
-class RadioType extends FieldType {
-    get options$() {
-        const options = this.props['options'];
-        return isObservable(options) ? options : of(options || []);
+    /**
+     * Validate that an entity has a UUID
+     * @param item The entity to validate
+     * @param action The action being performed
+     * @returns true if valid, false otherwise
+     */
+    validateItemUuid(item, action) {
+        if (!item?.uuid) {
+            this.showError(`${AppMessages.LIST.ERROR.INVALID_ID} ${action}`);
+            return false;
+        }
+        return true;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: RadioType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: RadioType, isStandalone: true, selector: "formly-field-radio", usesInheritance: true, ngImport: i0, template: `
-    <div class="flex flex-column gap-1">
-      <ng-container *ngIf="options$ | async as options">
-        <div *ngFor="let option of options; let i = index" class="flex align-items-center gap-2">
-          <p-radioButton
-            [name]="field.name || ''"
-            [value]="option.value"
-            [formControl]="$any(formControl)"
-            [formlyAttributes]="field"
-            [size]="'small'"
-            [inputId]="field.key + '_' + i">
-          </p-radioButton>
-          <label [for]="field.key + '_' + i" class="p-radio-label cursor-pointer">
-            {{option.label}}
-          </label>
-        </div>
-      </ng-container>
-    </div>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1$3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: RadioButtonModule }, { kind: "component", type: i4$1.RadioButton, selector: "p-radioButton, p-radiobutton, p-radio-button", inputs: ["value", "formControlName", "name", "disabled", "variant", "size", "tabindex", "inputId", "ariaLabelledBy", "ariaLabel", "style", "styleClass", "autofocus", "binary"], outputs: ["onClick", "onFocus", "onBlur"] }] });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseListPageComponent, deps: [{ token: i1$1.Router }, { token: NotificationService }, { token: UtilsService }, { token: i2.ConfirmationService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.6", type: BaseListPageComponent, isStandalone: true, usesInheritance: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: RadioType, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'formly-field-radio',
-                    standalone: true,
-                    imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        RadioButtonModule
-                    ],
-                    template: `
-    <div class="flex flex-column gap-1">
-      <ng-container *ngIf="options$ | async as options">
-        <div *ngFor="let option of options; let i = index" class="flex align-items-center gap-2">
-          <p-radioButton
-            [name]="field.name || ''"
-            [value]="option.value"
-            [formControl]="$any(formControl)"
-            [formlyAttributes]="field"
-            [size]="'small'"
-            [inputId]="field.key + '_' + i">
-          </p-radioButton>
-          <label [for]="field.key + '_' + i" class="p-radio-label cursor-pointer">
-            {{option.label}}
-          </label>
-        </div>
-      </ng-container>
-    </div>
-  `
-                }]
-        }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseListPageComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1$1.Router }, { type: NotificationService }, { type: UtilsService }, { type: i2.ConfirmationService }] });
 
-class NumericInputType extends FieldType {
-    defaultOptions = {
-        props: {
-            min: undefined,
-            max: undefined,
-            minFractionDigits: 0,
-            maxFractionDigits: 0,
-            prefix: '',
-            suffix: '',
-            useGrouping: true
+class BaseTabbedFormComponent extends BasePageComponent {
+    route;
+    router;
+    notificationService;
+    utilsService;
+    destroyed$ = new Subject();
+    stateManager$ = new BehaviorSubject(this.getInitialState());
+    getInitialState() {
+        return {
+            isNew: true,
+            mode: AppConstants.PAGE_MODE.CREATE,
+            currentData: {},
+            originalData: null,
+            hasChanges: false,
+            loading: false,
+            context: ComponentContext.TABBED,
+            activeTab: '',
+            tabs: []
+        };
+    }
+    get state() {
+        return this.stateManager$.value;
+    }
+    set state(value) {
+        // Only emit if there are actual changes
+        if (this.hasStateChanged(this.state, value)) {
+            this.stateManager$.next(value);
         }
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NumericInputType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: NumericInputType, isStandalone: true, selector: "formly-field-numeric-input", usesInheritance: true, ngImport: i0, template: `
-    <p-inputNumber
-      [formControl]="$any(formControl)"
-      [formlyAttributes]="field"
-      [placeholder]="props['placeholder'] || ''"
-      [min]="props['min'] || 0"
-      [max]="props['max']"
-      [minFractionDigits]="props['minFractionDigits'] || 0"
-      [maxFractionDigits]="props['maxFractionDigits'] || 0"
-      [prefix]="props['prefix'] || ''"
-      [suffix]="props['suffix'] || ''"
-      [useGrouping]="props['useGrouping'] ?? true"
-      [showButtons]="true"
-      class="w-full">
-    </p-inputNumber>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: InputNumberModule }, { kind: "component", type: i3$1.InputNumber, selector: "p-inputNumber, p-inputnumber, p-input-number", inputs: ["showButtons", "format", "buttonLayout", "inputId", "styleClass", "style", "placeholder", "size", "maxlength", "tabindex", "title", "ariaLabelledBy", "ariaLabel", "ariaRequired", "name", "required", "autocomplete", "min", "max", "incrementButtonClass", "decrementButtonClass", "incrementButtonIcon", "decrementButtonIcon", "readonly", "step", "allowEmpty", "locale", "localeMatcher", "mode", "currency", "currencyDisplay", "useGrouping", "variant", "minFractionDigits", "maxFractionDigits", "prefix", "suffix", "inputStyle", "inputStyleClass", "showClear", "autofocus", "disabled", "fluid"], outputs: ["onInput", "onFocus", "onBlur", "onKeyDown", "onClear"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: NumericInputType, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'formly-field-numeric-input',
-                    standalone: true,
-                    imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        InputNumberModule
-                    ],
-                    template: `
-    <p-inputNumber
-      [formControl]="$any(formControl)"
-      [formlyAttributes]="field"
-      [placeholder]="props['placeholder'] || ''"
-      [min]="props['min'] || 0"
-      [max]="props['max']"
-      [minFractionDigits]="props['minFractionDigits'] || 0"
-      [maxFractionDigits]="props['maxFractionDigits'] || 0"
-      [prefix]="props['prefix'] || ''"
-      [suffix]="props['suffix'] || ''"
-      [useGrouping]="props['useGrouping'] ?? true"
-      [showButtons]="true"
-      class="w-full">
-    </p-inputNumber>
-  `
-                }]
-        }] });
-
-class MultiselectType extends FieldType {
-    get options$() {
-        const options = this.props['options'];
-        return isObservable(options) ? options : of(options || []);
     }
-    defaultOptions = {
-        props: {
-            options: [],
-            optionLabel: 'label',
-            optionValue: 'value',
-            placeholder: 'Select',
-            filter: false,
-            maxSelectedLabels: 3,
-            showToggleAll: true,
-            virtualScroll: false
+    hasStateChanged(current, next) {
+        // Quick reference check
+        if (current === next)
+            return false;
+        // Check essential properties that affect rendering
+        return current.loading !== next.loading ||
+            current.activeTab !== next.activeTab ||
+            current.hasChanges !== next.hasChanges ||
+            current.mode !== next.mode ||
+            current.isNew !== next.isNew ||
+            !this.areTabsEqual(current.tabs, next.tabs) ||
+            this.detectChanges(current.currentData, next.currentData);
+    }
+    areTabsEqual(current, next) {
+        if (current === next)
+            return true;
+        if (current.length !== next.length)
+            return false;
+        return current.every((tab, index) => tab.value === next[index].value &&
+            tab.isParentModel === next[index].isParentModel);
+    }
+    constructor(route, router, notificationService, utilsService) {
+        super(utilsService, notificationService);
+        this.route = route;
+        this.router = router;
+        this.notificationService = notificationService;
+        this.utilsService = utilsService;
+    }
+    ngOnInit() {
+        this.initializeFormWithErrorHandling();
+        this.setupStateSubscription();
+    }
+    initializeFormWithErrorHandling() {
+        // Initialize tabs first
+        const tabs = this.getTabs();
+        this.state = {
+            ...this.state,
+            tabs,
+            activeTab: tabs[0]?.value || ''
+        };
+        // Then initialize form
+        this.route.queryParams.pipe(take$1(1), tap$1(() => this.state = { ...this.state, loading: true }), tap$1(params => this.initializeForm(params)), map$1(() => void 0), catchError$1(error => {
+            console.error('Error initializing form:', error);
+            this.showError(AppMessages.FORM.ERROR.INIT);
+            return of(void 0);
+        }), finalize(() => this.state = { ...this.state, loading: false }), takeUntil$1(this.destroyed$)).subscribe();
+    }
+    setupStateSubscription() {
+        this.stateManager$.pipe(distinctUntilChanged((prev, curr) => !this.hasStateChanged(prev, curr)), takeUntil$1(this.destroyed$)).subscribe(state => {
+            this.handleStateChange(state);
+        });
+    }
+    handleStateChange(state) {
+        // Track significant state changes
+        const stateUpdates = [];
+        if (state.loading) {
+            stateUpdates.push('loading');
+        }
+        if (state.hasChanges) {
+            stateUpdates.push('hasChanges');
+        }
+        if (state.activeTab) {
+            stateUpdates.push('activeTab');
+        }
+        if (stateUpdates.length > 0) {
+            console.log('[BaseTabbedFormComponent] State updated:', {
+                updates: stateUpdates,
+                activeTab: state.activeTab,
+                loading: state.loading,
+                hasChanges: state.hasChanges
+            });
+        }
+    }
+    initializeFormData() {
+        console.log('[BaseTabbedFormComponent] Initializing form data');
+        console.log('[BaseTabbedFormComponent] Current mode:', this.state.mode);
+        if (this.state.mode === AppConstants.PAGE_MODE.CREATE) {
+            console.log('[BaseTabbedFormComponent] Create mode, using defaults');
+            this.loadDefaultTab();
+            return;
+        }
+        const state = {
+            ...this.router.getCurrentNavigation()?.extras?.state,
+            ...window.history.state
+        };
+        console.log('[BaseTabbedFormComponent] Combined state:', state);
+        if (state?.formData) {
+            console.log('[BaseTabbedFormComponent] Found form data in state:', state.formData);
+            this.patchFormData(state.formData);
+            this.loadDefaultTab();
+        }
+        else {
+            console.log('[BaseTabbedFormComponent] No form data, loading from UUID');
+            this.loadFromUuid();
+        }
+    }
+    loadFromUuid() {
+        this.route.queryParams.pipe(take$1(1), map$1((params) => {
+            const uuid = params[AppConstants.FORM.UUID];
+            if (!uuid) {
+                throw new Error(`UUID is required for ${this.state.mode} mode when no formData is provided`);
+            }
+            return uuid;
+        }), tap$1(() => this.state = { ...this.state, loading: true }), tap$1(uuid => this.loadEntity(uuid)), catchError$1(error => {
+            console.error('Error loading UUID:', error);
+            this.showError(`${AppMessages.FORM.ERROR.LOAD} UUID`);
+            return of(void 0);
+        }), finalize(() => this.state = { ...this.state, loading: false }), takeUntil$1(this.destroyed$)).subscribe();
+    }
+    initializeForm(params) {
+        const routeMode = params[AppConstants.FORM.MODE];
+        try {
+            this.initializeFormMode(routeMode);
+            this.setupFormState();
+            this.initializeFormData();
+        }
+        catch (error) {
+            console.error('Error initializing form:', error);
+            this.showError(`${AppMessages.FORM.ERROR.INIT}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    patchFormData(data) {
+        if (data) {
+            this.state.currentData = { ...data };
+            this.state.originalData = { ...data }; // Create a deep copy to avoid reference issues
+            this.state.isNew = false;
+        }
+    }
+    initializeFormMode(routeMode) {
+        if (!routeMode) {
+            this.state.mode = AppConstants.PAGE_MODE.CREATE;
+            return;
+        }
+        // Validate mode more explicitly
+        if (!this.isValidPageMode(routeMode)) {
+            const validModes = Object.values(AppConstants.PAGE_MODE).join(', ');
+            throw new Error(`Invalid page mode: ${routeMode}. Valid modes are: ${validModes}`);
+        }
+        this.state.mode = routeMode;
+    }
+    setupFormState() {
+        console.log('[BaseTabbedFormComponent] Setting up form state, mode:', this.state.mode);
+        if (this.state.mode === AppConstants.PAGE_MODE.CREATE) {
+            console.log('[BaseTabbedFormComponent] Create mode setup');
+            this.state.isNew = true;
+            this.state.loading = false;
+            this.state.originalData = null;
+        }
+    }
+    loadEntity(uuid) {
+        const entityName = this.getEntityName();
+        this.getEntityService().getById(uuid).pipe(tap$1(() => this.state = {
+            ...this.state,
+            loading: true,
+            isNew: false
+        }), takeUntil$1(this.destroyed$)).subscribe({
+            next: (data) => {
+                this.state = {
+                    ...this.state,
+                    originalData: data,
+                    currentData: { ...data },
+                    loading: false
+                };
+                console.log('[BaseTabbedFormComponent] Data loaded:', { original: data, current: this.state.currentData });
+                this.loadDefaultTab();
+            },
+            error: (error) => {
+                console.error('[BaseTabbedFormComponent] Error loading entity:', error);
+                this.showError(`${AppMessages.FORM.ERROR.LOAD} ${entityName}`);
+                this.state = { ...this.state, loading: false };
+            }
+        });
+    }
+    findTabByValue(value) {
+        return this.state.tabs.find((tab) => tab.value === value);
+    }
+    loadDefaultTab() {
+        console.log('[BaseTabbedFormComponent] Loading default tab');
+        const defaultTab = this.state.tabs.find((tab) => tab.isParentModel) || this.state.tabs[0];
+        if (!defaultTab)
+            return;
+        const formData = this.getTabFormData(defaultTab);
+        this.router.navigate([defaultTab.value], {
+            relativeTo: this.route,
+            queryParamsHandling: 'preserve',
+            state: {
+                formData,
+                parentFormData: this.state.currentData,
+                context: ComponentContext.TABBED
+            }
+        });
+    }
+    getTabFormData(tabConfig) {
+        if (!tabConfig)
+            return null;
+        if (tabConfig.isParentModel) {
+            return this.state.currentData;
+        }
+        const fieldName = this.utilsService.toCamelCase(tabConfig.value);
+        const nestedData = this.state.currentData[fieldName];
+        if (this.isTabFormData(nestedData)) {
+            return nestedData;
+        }
+        console.warn(`Invalid tab form data for field: ${fieldName}`, nestedData);
+        return null;
+    }
+    isTabFormData(data) {
+        return data != null &&
+            typeof data === 'object' &&
+            'uuid' in data &&
+            typeof data.uuid === 'string';
+    }
+    onTabChange(value) {
+        const tabConfig = this.findTabByValue(value);
+        if (!tabConfig) {
+            console.warn(`Tab not found: ${value}`);
+            return;
+        }
+        this.state.activeTab = tabConfig.value;
+        const formData = this.getTabFormData(tabConfig);
+        this.router.navigate([this.state.activeTab], {
+            relativeTo: this.route,
+            queryParamsHandling: 'preserve',
+            state: {
+                formData: formData,
+                parentFormData: this.state.currentData,
+                context: ComponentContext.TABBED
+            }
+        });
+    }
+    hasFormChanges(currentData) {
+        if (this.state.isNew || !this.state.originalData) {
+            return true;
         }
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: MultiselectType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: MultiselectType, isStandalone: true, selector: "formly-field-multiselect", usesInheritance: true, ngImport: i0, template: `
-    <ng-container *ngIf="options$ | async as options">
-      <p-multiSelect
-        [formControl]="$any(formControl)"
-        [formlyAttributes]="field"
-        [options]="options"
-        [optionLabel]="props['optionLabel'] || 'label'"
-        [optionValue]="props['optionValue'] || 'value'"
-        [placeholder]="props['placeholder'] || 'Select'"
-        [filter]="props['filter'] || true"
-        [filterBy]="props['filterBy'] || 'label'"
-        [maxSelectedLabels]="props['maxSelectedLabels'] || 2"
-        [showToggleAll]="props['showToggleAll'] || true"
-        [virtualScroll]="props['virtualScroll'] || false"
-        [display]="props['display'] || 'chip'"
-        styleClass="w-full">
-      </p-multiSelect>
-    </ng-container>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1$3.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: MultiSelectModule }, { kind: "component", type: i4$2.MultiSelect, selector: "p-multiSelect, p-multiselect, p-multi-select", inputs: ["id", "ariaLabel", "style", "styleClass", "panelStyle", "panelStyleClass", "inputId", "disabled", "fluid", "readonly", "group", "filter", "filterPlaceHolder", "filterLocale", "overlayVisible", "tabindex", "variant", "appendTo", "dataKey", "name", "ariaLabelledBy", "displaySelectedLabel", "maxSelectedLabels", "selectionLimit", "selectedItemsLabel", "showToggleAll", "emptyFilterMessage", "emptyMessage", "resetFilterOnHide", "dropdownIcon", "chipIcon", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "showHeader", "filterBy", "scrollHeight", "lazy", "virtualScroll", "loading", "virtualScrollItemSize", "loadingIcon", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "filterMatchMode", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "autofocusFilter", "display", "autocomplete", "size", "showClear", "autofocus", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "defaultLabel", "placeholder", "options", "filterValue", "itemSize", "selectAll", "focusOnHover", "filterFields", "selectOnFocus", "autoOptionFocus"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onClear", "onPanelShow", "onPanelHide", "onLazyLoad", "onRemove", "onSelectAllChange"] }] });
+        return this.detectChanges(currentData, this.state.originalData);
+    }
+    detectChanges(current, original) {
+        try {
+            return JSON.stringify(current) !== JSON.stringify(original);
+        }
+        catch (error) {
+            console.error('[BaseTabbedFormComponent] Error comparing objects:', error);
+            // Fallback to basic comparison if JSON.stringify fails
+            return Object.keys(current).some(key => current[key] !== original[key]);
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+        this.stateManager$.complete();
+    }
+    isValidPageMode(mode) {
+        return Object.values(AppConstants.PAGE_MODE).includes(mode);
+    }
+    getTabTitle(data) {
+        throw new Error('Method not implemented.');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTabbedFormComponent, deps: [{ token: i1$1.ActivatedRoute }, { token: i1$1.Router }, { token: NotificationService }, { token: UtilsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: BaseTabbedFormComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTabbedFormComponent });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: MultiselectType, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTabbedFormComponent, decorators: [{
+            type: Injectable
+        }, {
             type: Component,
             args: [{
-                    selector: 'formly-field-multiselect',
-                    standalone: true,
-                    imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        MultiSelectModule
-                    ],
-                    template: `
-    <ng-container *ngIf="options$ | async as options">
-      <p-multiSelect
-        [formControl]="$any(formControl)"
-        [formlyAttributes]="field"
-        [options]="options"
-        [optionLabel]="props['optionLabel'] || 'label'"
-        [optionValue]="props['optionValue'] || 'value'"
-        [placeholder]="props['placeholder'] || 'Select'"
-        [filter]="props['filter'] || true"
-        [filterBy]="props['filterBy'] || 'label'"
-        [maxSelectedLabels]="props['maxSelectedLabels'] || 2"
-        [showToggleAll]="props['showToggleAll'] || true"
-        [virtualScroll]="props['virtualScroll'] || false"
-        [display]="props['display'] || 'chip'"
-        styleClass="w-full">
-      </p-multiSelect>
-    </ng-container>
-  `
+                    template: ''
                 }]
-        }] });
+        }], ctorParameters: () => [{ type: i1$1.ActivatedRoute }, { type: i1$1.Router }, { type: NotificationService }, { type: UtilsService }] });
 
-class DateType extends FieldType {
-    defaultOptions = {
-        props: {
-            dateFormat: 'dd-mm-yy',
-            showTime: false,
-            touchUI: false,
-            placeholder: '',
-            showButtonBar: true,
-        }
+class BaseListTabbedFormComponent extends BasePageComponent {
+    route;
+    router;
+    notificationService;
+    utilsService;
+    destroyed$ = new Subject();
+    tabState$ = new ReplaySubject(1);
+    state = {
+        form: new FormGroup({}),
+        fields: [],
+        isNew: true,
+        mode: AppConstants.PAGE_MODE.CREATE,
+        currentData: {},
+        originalData: null,
+        hasChanges: false,
+        loading: false,
+        context: ComponentContext.TABBED,
+        activeTab: '',
+        tabs: [],
+        formDataList: []
     };
-    onDateSelect(event) {
-        this.formatAndSetDate(event);
+    constructor(route, router, notificationService, utilsService) {
+        super(utilsService, notificationService);
+        this.route = route;
+        this.router = router;
+        this.notificationService = notificationService;
+        this.utilsService = utilsService;
     }
-    onDateInput(event) {
-        const inputValue = event.target.value.trim();
-        if (this.isValidDateInput(inputValue, this.props['dateFormat'] || 'dd-mm-yy')) {
-            const parsedDate = this.parseDate(inputValue, this.props['dateFormat'] || 'dd-mm-yy');
-            if (parsedDate) {
-                this.formatAndSetDate(parsedDate);
+    ngOnInit() {
+        this.initializeFormFromQueryParams();
+        this.setupTabStateSubscription();
+        this.setupRouteParamsSubscription();
+    }
+    initializeFormFromQueryParams() {
+        this.route.queryParams.pipe(take$1(1), catchError$1(error => {
+            console.error('Error initializing form:', error);
+            this.showError(AppMessages.FORM.ERROR.INIT);
+            throw error;
+        }), takeUntil$1(this.destroyed$)).subscribe(params => this.initializeForm(params));
+    }
+    setupTabStateSubscription() {
+        this.tabState$.pipe(distinctUntilChanged$1((prev, curr) => prev.activeTab === curr.activeTab &&
+            prev.currentData?.uuid === curr.currentData?.uuid), takeUntil$1(this.destroyed$)).subscribe(state => {
+            this.updateComponentState(state);
+        });
+    }
+    setupRouteParamsSubscription() {
+        this.route.params.pipe(takeUntil$1(this.destroyed$)).subscribe(params => {
+            const uuid = params['id'];
+            if (uuid && this.state.formDataList?.length) {
+                this.handleTabChange(uuid);
             }
+        });
+    }
+    handleTabChange(uuid) {
+        const selectedData = this.findTabData(uuid);
+        if (selectedData) {
+            this.tabState$.next({
+                activeTab: uuid,
+                currentData: selectedData,
+                originalData: { ...selectedData }
+            });
         }
         else {
-            this.formControl?.setErrors({ invalidDate: true });
+            console.warn(`[BaseListTabbedFormComponent] Tab data not found for uuid: ${uuid}`);
         }
     }
-    formatAndSetDate(date) {
-        if (this.formControl) {
-            const formattedDate = formatDate(date, 'dd-MM-yyyy', 'en-US');
-            this.formControl.setValue(formattedDate);
+    findTabData(uuid) {
+        return this.state.formDataList.find(data => data.uuid === uuid);
+    }
+    updateComponentState(tabState) {
+        this.state = {
+            ...this.state,
+            activeTab: tabState.activeTab,
+            currentData: tabState.currentData,
+            originalData: tabState.originalData
+        };
+    }
+    initializeForm(params) {
+        try {
+            const routeMode = params[AppConstants.FORM.MODE];
+            this.initializeFormMode(routeMode);
+            this.setupFormState();
+            this.initializeListForm();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error('Error initializing form:', error);
+            this.showError(`${AppMessages.FORM.ERROR.INIT}: ${errorMessage}`);
+            throw error; // Re-throw to trigger error handling in the subscription
         }
     }
-    parseDate(value, format) {
-        const parts = value.split(/[-/]/); // Split by common delimiters
-        if (parts.length === 3) {
-            const [day, month, year] = format === 'dd-mm-yy'
-                ? [parseInt(parts[0], 10), parseInt(parts[1], 10) - 1, parseInt(parts[2], 10)]
-                : [parseInt(parts[1], 10), parseInt(parts[0], 10) - 1, parseInt(parts[2], 10)];
-            return new Date(year, month, day);
+    initializeFormMode(routeMode) {
+        if (!routeMode) {
+            this.state.mode = AppConstants.PAGE_MODE.CREATE;
+            return;
         }
-        return null;
+        if (!this.isValidPageMode(routeMode)) {
+            const validModes = Object.values(AppConstants.PAGE_MODE).join(', ');
+            throw new Error(`Invalid page mode: ${routeMode}. Valid modes are: ${validModes}`);
+        }
+        this.state.mode = routeMode;
     }
-    isValidDateInput(value, format) {
-        const dateRegex = format === 'dd-mm-yy'
-            ? /^\d{2}-\d{2}-\d{4}$/
-            : /^\d{2}\/\d{2}\/\d{4}$/;
-        return dateRegex.test(value);
+    setupFormState() {
+        if (this.state.mode === AppConstants.PAGE_MODE.CREATE) {
+            this.state.isNew = true;
+            this.state.loading = false;
+            this.state.originalData = null;
+        }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: DateType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: DateType, isStandalone: true, selector: "formly-field-date", usesInheritance: true, ngImport: i0, template: `
-    <p-datepicker
-      [formControl]="$any(formControl)"
-      [formlyAttributes]="field"
-      [showIcon]="true"
-      [dateFormat]="props['dateFormat'] || 'dd-mm-yy'"
-      [showTime]="props['showTime'] || false"
-      [touchUI]="props['touchUI'] || false"
-      [placeholder]="props['placeholder'] || ''"
-      [minDate]="props['minDate']"
-      [maxDate]="props['maxDate']"
-      [showOnFocus]="false"
-      [todayButtonStyleClass]="'p-button-secondary'"
-      [clearButtonStyleClass]="'p-button-secondary'"
-      styleClass="w-full"
-      (onSelect)="onDateSelect($event)"
-      (onInput)="onDateInput($event)">
-    </p-datepicker>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: DatePickerModule }, { kind: "component", type: i3$2.DatePicker, selector: "p-datePicker, p-datepicker, p-date-picker", inputs: ["iconDisplay", "style", "styleClass", "inputStyle", "inputId", "name", "inputStyleClass", "placeholder", "ariaLabelledBy", "ariaLabel", "iconAriaLabel", "disabled", "dateFormat", "multipleSeparator", "rangeSeparator", "inline", "showOtherMonths", "selectOtherMonths", "showIcon", "fluid", "icon", "appendTo", "readonlyInput", "shortYearCutoff", "monthNavigator", "yearNavigator", "hourFormat", "timeOnly", "stepHour", "stepMinute", "stepSecond", "showSeconds", "required", "showOnFocus", "showWeek", "startWeekFromFirstDayOfYear", "showClear", "dataType", "selectionMode", "maxDateCount", "showButtonBar", "todayButtonStyleClass", "clearButtonStyleClass", "autofocus", "autoZIndex", "baseZIndex", "panelStyleClass", "panelStyle", "keepInvalid", "hideOnDateTimeSelect", "touchUI", "timeSeparator", "focusTrap", "showTransitionOptions", "hideTransitionOptions", "tabindex", "variant", "size", "minDate", "maxDate", "disabledDates", "disabledDays", "yearRange", "showTime", "responsiveOptions", "numberOfMonths", "firstDayOfWeek", "locale", "view", "defaultDate"], outputs: ["onFocus", "onBlur", "onClose", "onSelect", "onClear", "onInput", "onTodayClick", "onClearClick", "onMonthChange", "onYearChange", "onClickOutside", "onShow"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: DateType, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'formly-field-date',
-                    standalone: true,
-                    imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        DatePickerModule
-                    ],
-                    template: `
-    <p-datepicker
-      [formControl]="$any(formControl)"
-      [formlyAttributes]="field"
-      [showIcon]="true"
-      [dateFormat]="props['dateFormat'] || 'dd-mm-yy'"
-      [showTime]="props['showTime'] || false"
-      [touchUI]="props['touchUI'] || false"
-      [placeholder]="props['placeholder'] || ''"
-      [minDate]="props['minDate']"
-      [maxDate]="props['maxDate']"
-      [showOnFocus]="false"
-      [todayButtonStyleClass]="'p-button-secondary'"
-      [clearButtonStyleClass]="'p-button-secondary'"
-      styleClass="w-full"
-      (onSelect)="onDateSelect($event)"
-      (onInput)="onDateInput($event)">
-    </p-datepicker>
-  `
-                }]
-        }] });
-
-class CheckboxType extends FieldType {
-    defaultOptions = {
-        props: {
-            trueValue: true,
-            falseValue: false
+    initializeListForm() {
+        const routerState = this.router.getCurrentNavigation()?.extras?.state || window.history.state;
+        const formDataList = routerState?.formDataList;
+        if (!formDataList?.length) {
+            throw new Error('formDataList is required in state for LIST type');
         }
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CheckboxType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: CheckboxType, isStandalone: true, selector: "formly-field-checkbox", usesInheritance: true, ngImport: i0, template: `
-    <div class="checkbox-container">
-      <p-checkbox
-        [formControl]="$any(formControl)"
-        [formlyAttributes]="field"
-        [binary]="!props['options']"
-        [trueValue]="props['trueValue']"
-        [falseValue]="props['falseValue']">
-        {{props['checkboxLabel'] || ''}}
-      </p-checkbox>
-    </div>
-  `, isInline: true, styles: [".checkbox-container{display:flex;align-items:center;height:40px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: CheckboxModule }, { kind: "component", type: i3$3.Checkbox, selector: "p-checkbox, p-checkBox, p-check-box", inputs: ["value", "name", "disabled", "binary", "ariaLabelledBy", "ariaLabel", "tabindex", "inputId", "style", "inputStyle", "styleClass", "inputClass", "indeterminate", "size", "formControl", "checkboxIcon", "readonly", "required", "autofocus", "trueValue", "falseValue", "variant"], outputs: ["onChange", "onFocus", "onBlur"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CheckboxType, decorators: [{
-            type: Component,
-            args: [{ selector: 'formly-field-checkbox', standalone: true, imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        CheckboxModule
-                    ], template: `
-    <div class="checkbox-container">
-      <p-checkbox
-        [formControl]="$any(formControl)"
-        [formlyAttributes]="field"
-        [binary]="!props['options']"
-        [trueValue]="props['trueValue']"
-        [falseValue]="props['falseValue']">
-        {{props['checkboxLabel'] || ''}}
-      </p-checkbox>
-    </div>
-  `, styles: [".checkbox-container{display:flex;align-items:center;height:40px}\n"] }]
-        }] });
-
-class TextareaType extends FieldType {
-    defaultOptions = {
-        props: {
-            rows: 3,
-            cols: undefined,
-            autoResize: true,
-            placeholder: ''
+        this.state.formDataList = [...formDataList]; // Create a new array to avoid reference issues
+        this.state.tabs = this.createTabsFromFormDataList(this.state.formDataList);
+        const firstTab = this.state.tabs[0].value;
+        const firstItem = this.state.formDataList[0];
+        // Initialize tab state
+        this.tabState$.next({
+            activeTab: firstTab,
+            currentData: firstItem,
+            originalData: { ...firstItem }
+        });
+        // Navigate to the first tab
+        this.navigateToTab(firstTab);
+    }
+    createTabsFromFormDataList(formDataList) {
+        return formDataList.map((data) => ({
+            value: data.uuid,
+            title: this.getTabTitle(data)
+        }));
+    }
+    onTabChange(event) {
+        const uuid = event?.toString() || '';
+        console.log('[BaseListTabbedFormComponent] Tab change event:', uuid);
+        const selectedData = this.findTabData(uuid);
+        if (selectedData) {
+            this.handleTabChange(uuid);
+            this.navigateToTab(uuid);
         }
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextareaType, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: TextareaType, isStandalone: true, selector: "formly-field-textarea", usesInheritance: true, ngImport: i0, template: `
-    <textarea pInputTextarea
-      [formControl]="$any(formControl)"
-      [formlyAttributes]="field"
-      [rows]="props['rows'] || 3"
-      [cols]="props['cols']"
-      [autoResize]="props['autoResize']"
-      [placeholder]="props['placeholder'] || ''"
-      class="w-full">
-    </textarea>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1$4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormlyModule }, { kind: "directive", type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { kind: "ngmodule", type: Textarea }, { kind: "directive", type: i3$4.InputTextarea, selector: "[pInputTextarea]", inputs: ["autoResize", "variant", "fluid"], outputs: ["onResize"] }] });
+        else {
+            console.warn(`[BaseListTabbedFormComponent] Tab data not found for uuid: ${uuid}`);
+        }
+    }
+    navigateToTab(uuid) {
+        const selectedData = this.findTabData(uuid);
+        if (!selectedData) {
+            console.error(`[BaseListTabbedFormComponent] Cannot navigate: No data found for uuid ${uuid}`);
+            return;
+        }
+        this.router.navigate([uuid], {
+            relativeTo: this.route,
+            queryParamsHandling: 'preserve',
+            state: {
+                formData: selectedData,
+                context: ComponentContext.TABBED
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+        this.tabState$.complete();
+    }
+    isValidPageMode(mode) {
+        return Object.values(AppConstants.PAGE_MODE).includes(mode);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseListTabbedFormComponent, deps: [{ token: i1$1.ActivatedRoute }, { token: i1$1.Router }, { token: NotificationService }, { token: UtilsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: BaseListTabbedFormComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseListTabbedFormComponent });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: TextareaType, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseListTabbedFormComponent, decorators: [{
+            type: Injectable
+        }, {
             type: Component,
             args: [{
-                    selector: 'formly-field-textarea',
-                    standalone: true,
-                    imports: [
-                        CommonModule,
-                        ReactiveFormsModule,
-                        FormlyModule,
-                        Textarea
-                    ],
-                    template: `
-    <textarea pInputTextarea
-      [formControl]="$any(formControl)"
-      [formlyAttributes]="field"
-      [rows]="props['rows'] || 3"
-      [cols]="props['cols']"
-      [autoResize]="props['autoResize']"
-      [placeholder]="props['placeholder'] || ''"
-      class="w-full">
-    </textarea>
-  `
+                    template: ''
                 }]
-        }] });
+        }], ctorParameters: () => [{ type: i1$1.ActivatedRoute }, { type: i1$1.Router }, { type: NotificationService }, { type: UtilsService }] });
 
-class FormFieldWrapper extends FieldWrapper {
-    get errorMessage() {
-        if (!this.field.formControl?.errors) {
-            return '';
-        }
-        const firstErrorKey = Object.keys(this.field.formControl.errors)[0];
-        return this.props.validation?.messages?.[firstErrorKey] || 'This field is required';
+/**
+ * Base component for all task detail components in the application.
+ * Uses composition with FormService for form functionality.
+ */
+class BaseTaskDetailsComponent extends BasePageComponent {
+    route;
+    router;
+    notificationService;
+    utilsService;
+    formlyConfigService;
+    destroyed$ = new Subject();
+    formService;
+    state = {
+        form: new FormGroup({}),
+        fields: [],
+        isNew: true,
+        mode: AppConstants.PAGE_MODE.CREATE,
+        currentData: {},
+        originalData: null,
+        hasChanges: false,
+        loading: false,
+        context: ComponentContext.STANDALONE
+    };
+    constructor(route, router, notificationService, utilsService, formlyConfigService) {
+        super(utilsService, notificationService);
+        this.route = route;
+        this.router = router;
+        this.notificationService = notificationService;
+        this.utilsService = utilsService;
+        this.formlyConfigService = formlyConfigService;
     }
-    get showError() {
-        if (!this.field.formControl) {
-            return false;
+    initializeServices() {
+        return of(void 0).pipe(map(() => {
+            this.formService = new FormService(this.getEntityService(), this.formlyConfigService, this.notificationService, this.getEntityName(), this.getJsonFields(), this.getDropdownOptions());
+            this.state = this.formService.getState();
+            this.loading = this.state.loading;
+        }));
+    }
+    ngOnInit() {
+        this.initializeServices()
+            .pipe(switchMap(() => this.initializeFromRoute()), takeUntil(this.destroyed$))
+            .subscribe({
+            next: () => this.onInitialized(),
+            error: error => this.handleInitError(error)
+        });
+    }
+    initializeFromRoute() {
+        return this.route.queryParams.pipe(map(params => {
+            const mode = params[AppConstants.FORM.MODE];
+            if (mode) {
+                this.formService.setMode(mode);
+                this.state = this.formService.getState();
+            }
+            const uuid = params[AppConstants.FORM.UUID];
+            if (uuid) {
+                this.loadData(uuid);
+            }
+            // Check for context in router state
+            const routerState = window.history.state;
+            if (routerState?.context) {
+                this.state.context = routerState.context;
+            }
+        }));
+    }
+    loadData(uuid) {
+        this.state.loading = true;
+        this.formService.loadData(uuid)
+            .pipe(takeUntil(this.destroyed$), finalize$1(() => {
+            this.state.loading = false;
+            this.state = this.formService.getState();
+        }))
+            .subscribe({
+            error: (error) => this.handleLoadError(error)
+        });
+    }
+    onSubmit() {
+        this.formService.submit()
+            .pipe(takeUntil(this.destroyed$))
+            .subscribe({
+            next: () => this.navigateAfterSubmit(),
+            error: (error) => this.handleSubmitError(error)
+        });
+    }
+    navigateAfterSubmit() {
+        if (this.isInContext(ComponentContext.TABBED)) {
+            return; // Stay on current route when in tab
         }
-        const { touched, dirty, invalid } = this.field.formControl;
-        return invalid && (touched || dirty);
+        this.router.navigate([`/${this.getEntityName().toLowerCase()}s`]);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormFieldWrapper, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.6", type: FormFieldWrapper, isStandalone: true, selector: "formly-wrapper-form-field", usesInheritance: true, ngImport: i0, template: `
-    <div class="field mb-4">
-      <label *ngIf="props.label" [for]="id" class="font-medium">
-        {{ props.label }}
-        <span class="required-star" *ngIf="props.required">*</span>
-        <i *ngIf="props.tooltip" 
-           class="pi pi-info-circle ml-2" 
-           [pTooltip]="props.tooltip">
-        </i>
-      </label>
-      
-      <div [class.p-input-error]="showError">
-        <ng-container #fieldComponent></ng-container>
-      </div>
-      
-      <small *ngIf="props.description" class="block mt-1">
-        {{ props.description }}
-      </small>
-      
-      <small *ngIf="showError" class="p-error block">
-        <i class="pi pi-exclamation-circle mr-2"></i>
-        {{ errorMessage }}
-      </small>
-    </div>
-  `, isInline: true, styles: [":is() .required-star{color:var(--red-500);margin-left:.25rem}:is() .p-input-error :where(input,.p-inputtext){border-color:var(--red-500)}:is() .p-input-error :where(input:enabled:focus,.p-inputtext:enabled:focus){border-color:var(--red-500);box-shadow:0 0 0 1px var(--red-500)}:is() .p-error{color:var(--red-500);margin-top:.5rem}:is() small{color:var(--text-color-secondary)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i2$1.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }] });
+    onInitialized() {
+        console.log('[BaseTaskDetailsComponent] Initialized successfully');
+    }
+    handleInitError(error) {
+        console.error('Initialization error:', error);
+        this.notificationService.showError(AppMessages.FORM.ERROR.INIT);
+        this.state.loading = false;
+    }
+    handleLoadError(error) {
+        console.error('Load error:', error);
+        this.notificationService.showError(`Failed to load ${this.getEntityName()}`);
+    }
+    handleSubmitError(error) {
+        console.error('Submit error:', error);
+        const errorMessage = error.error?.message || `Failed to save ${this.getEntityName()}`;
+        this.showError(errorMessage);
+    }
+    isInContext(contextType) {
+        return this.state.context === contextType;
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTaskDetailsComponent, deps: [{ token: i1$1.ActivatedRoute }, { token: i1$1.Router }, { token: NotificationService }, { token: UtilsService }, { token: FormlyConfigService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.6", type: BaseTaskDetailsComponent, isStandalone: true, usesInheritance: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FormFieldWrapper, decorators: [{
-            type: Component,
-            args: [{ selector: 'formly-wrapper-form-field', standalone: true, imports: [CommonModule, TooltipModule], template: `
-    <div class="field mb-4">
-      <label *ngIf="props.label" [for]="id" class="font-medium">
-        {{ props.label }}
-        <span class="required-star" *ngIf="props.required">*</span>
-        <i *ngIf="props.tooltip" 
-           class="pi pi-info-circle ml-2" 
-           [pTooltip]="props.tooltip">
-        </i>
-      </label>
-      
-      <div [class.p-input-error]="showError">
-        <ng-container #fieldComponent></ng-container>
-      </div>
-      
-      <small *ngIf="props.description" class="block mt-1">
-        {{ props.description }}
-      </small>
-      
-      <small *ngIf="showError" class="p-error block">
-        <i class="pi pi-exclamation-circle mr-2"></i>
-        {{ errorMessage }}
-      </small>
-    </div>
-  `, styles: [":is() .required-star{color:var(--red-500);margin-left:.25rem}:is() .p-input-error :where(input,.p-inputtext){border-color:var(--red-500)}:is() .p-input-error :where(input:enabled:focus,.p-inputtext:enabled:focus){border-color:var(--red-500);box-shadow:0 0 0 1px var(--red-500)}:is() .p-error{color:var(--red-500);margin-top:.5rem}:is() small{color:var(--text-color-secondary)}\n"] }]
-        }] });
-
-const FORMLY_TYPES = {
-    TEXT: 'text',
-    NUMBER: 'number',
-    DATE: 'date',
-    CHECKBOX: 'checkbox',
-    RADIO: 'radio',
-    SELECT: 'select',
-    MULTISELECT: 'multiselect',
-    TEXTAREA: 'textarea'
-};
-const FORMLY_WRAPPERS = {
-    FORM_FIELD: 'form-field'
-};
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: BaseTaskDetailsComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1$1.ActivatedRoute }, { type: i1$1.Router }, { type: NotificationService }, { type: UtilsService }, { type: FormlyConfigService }] });
 
-class CoreFormlyModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, imports: [i2.FormlyModule], exports: [FormlyModule] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, imports: [FormlyModule.forRoot({
-                types: [
-                    { name: FORMLY_TYPES.TEXT, component: TextInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                    { name: FORMLY_TYPES.NUMBER, component: NumericInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                    { name: FORMLY_TYPES.DATE, component: DateType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                    { name: FORMLY_TYPES.CHECKBOX, component: CheckboxType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                    { name: FORMLY_TYPES.RADIO, component: RadioType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                    { name: FORMLY_TYPES.SELECT, component: SelectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                    { name: FORMLY_TYPES.MULTISELECT, component: MultiselectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                    { name: FORMLY_TYPES.TEXTAREA, component: TextareaType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] }, // Added textarea type
-                ],
-                wrappers: [
-                    { name: FORMLY_WRAPPERS.FORM_FIELD, component: FormFieldWrapper }
-                ]
-            }), FormlyModule] });
+class IndianDatePipe {
+    datePipe;
+    constructor(datePipe) {
+        this.datePipe = datePipe;
+    }
+    transform(value, format = 'default') {
+        if (!value)
+            return null;
+        // First validate dd-MM-yyyy format
+        const dateRegex = /^(0[1-9]|[12][0-9]|3[01])-(0[1-9]|1[0-2])-\d{4}$/;
+        if (!dateRegex.test(value)) {
+            throw new Error(`Invalid date format: ${value}. Expected format: dd-MM-yyyy`);
+        }
+        // Validate real date
+        const [day, month, year] = value.split('-').map(Number);
+        const date = new Date(year, month - 1, day);
+        if (date.getFullYear() !== year ||
+            date.getMonth() !== month - 1 ||
+            date.getDate() !== day) {
+            throw new Error(`Invalid date: ${value}`);
+        }
+        // Apply requested format
+        switch (format) {
+            case 'short':
+                // Pad with leading zeros for consistent format
+                const paddedDay = day.toString().padStart(2, '0');
+                const paddedMonth = month.toString().padStart(2, '0');
+                return `${paddedDay}-${paddedMonth}-${year}`; // 10-03-2025
+            case 'medium':
+                return this.datePipe.transform(date, 'dd MMM yyyy'); // 10 Jan 2019
+            default:
+                return value; // original dd-MM-yyyy
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: IndianDatePipe, deps: [{ token: i1$3.DatePipe }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.6", ngImport: i0, type: IndianDatePipe, isStandalone: true, name: "indianDate" });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CoreFormlyModule, decorators: [{
-            type: NgModule,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: IndianDatePipe, decorators: [{
+            type: Pipe,
             args: [{
-                    imports: [
-                        FormlyModule.forRoot({
-                            types: [
-                                { name: FORMLY_TYPES.TEXT, component: TextInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                                { name: FORMLY_TYPES.NUMBER, component: NumericInputType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                                { name: FORMLY_TYPES.DATE, component: DateType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                                { name: FORMLY_TYPES.CHECKBOX, component: CheckboxType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                                { name: FORMLY_TYPES.RADIO, component: RadioType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                                { name: FORMLY_TYPES.SELECT, component: SelectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                                { name: FORMLY_TYPES.MULTISELECT, component: MultiselectType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] },
-                                { name: FORMLY_TYPES.TEXTAREA, component: TextareaType, wrappers: [FORMLY_WRAPPERS.FORM_FIELD] }, // Added textarea type
-                            ],
-                            wrappers: [
-                                { name: FORMLY_WRAPPERS.FORM_FIELD, component: FormFieldWrapper }
-                            ]
-                        })
-                    ],
-                    exports: [FormlyModule]
+                    name: 'indianDate',
+                    standalone: true
                 }]
-        }] });
+        }], ctorParameters: () => [{ type: i1$3.DatePipe }] });
 
 /*
  * Public API Surface of core-lib
  */
-// Services
+// Constants
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AppConstants, AppMessages, BaseCrudService, BaseFormComponent, BaseListPageComponent, BasePageComponent, BaseTabbedFormComponent, CheckboxType, ComponentContext, CoreFormlyModule, DateType, EntityRegistryService, EnumRegistryService, FormFieldWrapper, FormlyConfigService, HttpUtilityService, IndianDatePipe, MultiselectType, NotificationService, NumericInputType, RadioType, ReferenceDataProviderService, SelectType, TabbedFormType, TextInputType, UtilsService };
+export { AppConstants, AppMessages, BaseCrudService, BaseFormComponent, BaseListPageComponent, BaseListTabbedFormComponent, BasePageComponent, BaseTabbedFormComponent, BaseTaskDetailsComponent, BaseTaskService, ComponentContext, CoreFormlyModule, FormService, FormlyConfigService, HttpUtilityService, IndianDatePipe, KEYCLOAK_CONFIG, KeycloakAuthGuard, KeycloakService, NotificationService, TabbedFormType, TaskRole, UtilsService };
 //# sourceMappingURL=codex-ts-core-lib.mjs.map