@codex-ts/core-lib 1.0.0

package/dist/core-lib/fesm2022/core-lib.mjs

@@ -0,0 +1,2349 @@
+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 { HttpParams } from '@angular/common/http';
+import { retry, timeout, catchError, finalize as finalize$1 } from 'rxjs/operators';
+import * as i1$4 from '@angular/forms';
+import { FormGroup, ReactiveFormsModule } from '@angular/forms';
+import * as i1$2 from '@angular/router';
+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';
+import { SelectModule } from 'primeng/select';
+import * as i4$1 from 'primeng/radiobutton';
+import { RadioButtonModule } from 'primeng/radiobutton';
+import * as i3$1 from 'primeng/inputnumber';
+import { InputNumberModule } from 'primeng/inputnumber';
+import * as i4$2 from 'primeng/multiselect';
+import { MultiSelectModule } from 'primeng/multiselect';
+import * as i3$2 from 'primeng/datepicker';
+import { DatePickerModule } from 'primeng/datepicker';
+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 { TooltipModule } from 'primeng/tooltip';
+
+/**
+ * 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);
+    }
+    /**
+     * Shows an error message using PrimeNG's MessageService
+     * @param message The error message to display
+     * @param messageService The MessageService instance to use
+     */
+    showError(message, messageService) {
+        if (messageService) {
+            messageService.add({
+                severity: 'error',
+                summary: 'Error',
+                detail: message,
+                life: 3000
+            });
+        }
+    }
+    /**
+     * Shows a success message using PrimeNG's MessageService
+     * @param message The success message to display
+     * @param messageService The MessageService instance to use
+     */
+    showSuccess(message, messageService) {
+        if (messageService) {
+            messageService.add({
+                severity: 'success',
+                summary: 'Success',
+                detail: message,
+                life: 3000
+            });
+        }
+    }
+    /**
+     * 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
+     */
+    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;
+    }
+    /**
+     * 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
+        }));
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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();
+    }
+    /**
+     * 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 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.4", ngImport: i0, type: UtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: UtilsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class EnumRegistryService {
+    utilsService;
+    enumMap = new Map();
+    constructor(utilsService) {
+        this.utilsService = utilsService;
+    }
+    /**
+     * 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 [];
+        }
+        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.4", ngImport: i0, type: EnumRegistryService, deps: [{ token: UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: EnumRegistryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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
+                }
+            };
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: FormlyConfigService, deps: [{ token: EnumRegistryService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: FormlyConfigService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: FormlyConfigService, 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.4", ngImport: i0, type: NotificationService, deps: [{ token: i1.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.MessageService }] });
+
+/**
+ * A general-purpose HTTP utility service that provides enhanced HTTP operations
+ * beyond the standard Angular HttpClient. This service includes features such as:
+ * - Loading state management
+ * - Standardized error handling
+ * - Request timeouts and retries
+ * - File upload capabilities
+ * - Batch request handling
+ */
+class HttpUtilityService {
+    http;
+    messageService;
+    loading = new BehaviorSubject(false);
+    loading$ = this.loading.asObservable();
+    constructor(http, messageService) {
+        this.http = http;
+        this.messageService = messageService;
+    }
+    /**
+     * Perform a GET request with enhanced options
+     * @param url The endpoint URL
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    get(url, options) {
+        this.loading.next(true);
+        let request$ = this.http.get(url, {
+            params: options?.params,
+            headers: options?.headers,
+            responseType: options?.responseType,
+            withCredentials: options?.withCredentials
+        });
+        if (options?.retries) {
+            request$ = request$.pipe(retry(options.retries));
+        }
+        if (options?.timeoutMs) {
+            request$ = request$.pipe(timeout(options.timeoutMs));
+        }
+        return request$.pipe(catchError(this.handleError.bind(this)), finalize(() => this.loading.next(false)));
+    }
+    /**
+     * Perform a POST request with enhanced options
+     * @param url The endpoint URL
+     * @param body The request payload
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    post(url, body, options) {
+        this.loading.next(true);
+        let request$ = this.http.post(url, body, {
+            params: options?.params,
+            headers: options?.headers,
+            responseType: options?.responseType,
+            withCredentials: options?.withCredentials
+        });
+        if (options?.retries) {
+            request$ = request$.pipe(retry(options.retries));
+        }
+        if (options?.timeoutMs) {
+            request$ = request$.pipe(timeout(options.timeoutMs));
+        }
+        return request$.pipe(catchError(this.handleError.bind(this)), finalize(() => this.loading.next(false)));
+    }
+    /**
+     * Perform a PUT request with enhanced options
+     * @param url The endpoint URL
+     * @param body The request payload
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    put(url, body, options) {
+        this.loading.next(true);
+        let request$ = this.http.put(url, body, {
+            params: options?.params,
+            headers: options?.headers,
+            responseType: options?.responseType,
+            withCredentials: options?.withCredentials
+        });
+        if (options?.retries) {
+            request$ = request$.pipe(retry(options.retries));
+        }
+        if (options?.timeoutMs) {
+            request$ = request$.pipe(timeout(options.timeoutMs));
+        }
+        return request$.pipe(catchError(this.handleError.bind(this)), finalize(() => this.loading.next(false)));
+    }
+    /**
+     * Perform a DELETE request with enhanced options
+     * @param url The endpoint URL
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    delete(url, options) {
+        this.loading.next(true);
+        let request$ = this.http.delete(url, {
+            params: options?.params,
+            headers: options?.headers,
+            responseType: options?.responseType,
+            withCredentials: options?.withCredentials
+        });
+        if (options?.retries) {
+            request$ = request$.pipe(retry(options.retries));
+        }
+        if (options?.timeoutMs) {
+            request$ = request$.pipe(timeout(options.timeoutMs));
+        }
+        return request$.pipe(catchError(this.handleError.bind(this)), finalize(() => this.loading.next(false)));
+    }
+    /**
+     * Upload a file with optional additional data
+     * @param url The upload endpoint URL
+     * @param file The file to upload
+     * @param additionalData Additional form data to include
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    uploadFile(url, file, additionalData, options) {
+        this.loading.next(true);
+        const formData = new FormData();
+        formData.append('file', file, file.name);
+        if (additionalData) {
+            Object.keys(additionalData).forEach(key => {
+                formData.append(key, additionalData[key]);
+            });
+        }
+        let httpOptions = {
+            headers: options?.headers,
+            withCredentials: options?.withCredentials
+        };
+        // If progress tracking is requested
+        if (options?.onProgress) {
+            httpOptions.reportProgress = true;
+            httpOptions.observe = 'events';
+        }
+        // Create the request
+        let request$ = this.http.post(url, formData, httpOptions);
+        // Add retries if specified
+        if (options?.retries) {
+            request$ = request$.pipe(retry(options.retries));
+        }
+        // Add timeout if specified
+        if (options?.timeoutMs) {
+            request$ = request$.pipe(timeout(options.timeoutMs));
+        }
+        // Track progress if a callback is provided
+        if (options?.onProgress) {
+            return new Observable(observer => {
+                request$.subscribe({
+                    next: (event) => {
+                        if (event.type === 1 && event.total) { // HttpEventType.UploadProgress
+                            const percentDone = Math.round(100 * event.loaded / event.total);
+                            options.onProgress(percentDone);
+                        }
+                        else if (event.type === 4) { // HttpEventType.Response
+                            observer.next(event.body);
+                            observer.complete();
+                        }
+                    },
+                    error: (error) => {
+                        observer.error(this.handleError(error));
+                        this.loading.next(false);
+                    },
+                    complete: () => {
+                        this.loading.next(false);
+                    }
+                });
+            });
+        }
+        // Standard request without progress tracking
+        return request$.pipe(catchError(this.handleError.bind(this)), finalize(() => this.loading.next(false)));
+    }
+    /**
+     * Execute multiple HTTP requests in parallel
+     * @param requests Array of HTTP request observables
+     * @returns An observable that emits when all requests complete
+     */
+    batchRequests(requests) {
+        this.loading.next(true);
+        return forkJoin(requests).pipe(catchError(this.handleError.bind(this)), finalize(() => this.loading.next(false)));
+    }
+    /**
+     * Download a file from the server
+     * @param url The file URL
+     * @param filename Optional filename to save as
+     * @param options Additional request options
+     */
+    downloadFile(url, filename, options) {
+        this.loading.next(true);
+        let request$ = this.http.get(url, {
+            params: options?.params,
+            headers: options?.headers,
+            responseType: 'blob',
+            withCredentials: options?.withCredentials
+        });
+        if (options?.timeoutMs) {
+            request$ = request$.pipe(timeout(options.timeoutMs));
+        }
+        return request$.pipe(catchError(this.handleError.bind(this)), finalize(() => this.loading.next(false)));
+    }
+    /**
+     * Create parameter string from an object
+     * @param params Object containing parameters
+     * @returns HttpParams object
+     */
+    createParams(params) {
+        let httpParams = new HttpParams();
+        Object.keys(params).forEach(key => {
+            const value = params[key];
+            if (value !== undefined && value !== null) {
+                httpParams = httpParams.append(key, value.toString());
+            }
+        });
+        return httpParams;
+    }
+    /**
+     * Standardized error handler for HTTP requests
+     * @param error The HTTP error
+     * @returns An observable that errors with the processed error object
+     */
+    handleError(error) {
+        console.error('An HTTP error occurred:', error);
+        let errorMessage = 'An error occurred';
+        let errorCode;
+        if (error.error instanceof ErrorEvent) {
+            // Client-side error
+            errorMessage = error.error.message;
+        }
+        else {
+            // Server-side error
+            errorCode = error.status.toString();
+            switch (error.status) {
+                case 400:
+                    errorMessage = error.error?.message || 'Bad request';
+                    break;
+                case 401:
+                    errorMessage = 'Unauthorized';
+                    break;
+                case 403:
+                    errorMessage = 'Access denied';
+                    break;
+                case 404:
+                    errorMessage = 'Resource not found';
+                    break;
+                case 408:
+                    errorMessage = 'Request timeout';
+                    break;
+                case 500:
+                    errorMessage = 'Server error';
+                    break;
+                case 503:
+                    errorMessage = 'Service unavailable';
+                    break;
+                default:
+                    errorMessage = error.error?.message || `Error ${error.status}`;
+                    break;
+            }
+        }
+        this.showError(errorMessage);
+        return throwError(() => ({
+            error,
+            message: errorMessage,
+            code: errorCode
+        }));
+    }
+    /**
+     * Display an error message using the message service
+     * @param message Error message to display
+     */
+    showError(message) {
+        if (this.messageService) {
+            this.messageService.add({
+                severity: 'error',
+                summary: 'Error',
+                detail: message,
+                life: 3000
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HttpUtilityService, deps: [{ token: i1$1.HttpClient }, { token: i1.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HttpUtilityService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HttpUtilityService, decorators: [{
+            type: Injectable,
+            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.4", ngImport: i0, type: ReferenceDataProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ReferenceDataProviderService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ReferenceDataProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class EntityRegistryService {
+    httpUtility;
+    dataProvider;
+    constructor(httpUtility, dataProvider) {
+        this.httpUtility = httpUtility;
+        this.dataProvider = dataProvider;
+    }
+    /**
+     * 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
+     */
+    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();
+            });
+        }
+        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.4", ngImport: i0, type: EntityRegistryService, deps: [{ token: HttpUtilityService }, { token: ReferenceDataProviderService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: EntityRegistryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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
+     */
+    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);
+    }
+    /**
+     * Joins URL parts ensuring no double slashes
+     */
+    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);
+        }
+    }
+    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}`);
+    }
+}
+
+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 = {}));
+
+/**
+ * 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.4", ngImport: i0, type: BasePageComponent, deps: [{ token: UtilsService }, { token: NotificationService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.4", type: BasePageComponent, isStandalone: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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'
+        }
+    },
+    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'
+        }
+    }
+};
+
+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;
+    utilsService;
+    formlyConfigService;
+    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;
+        this.utilsService = utilsService;
+        this.formlyConfigService = formlyConfigService;
+    }
+    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);
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ngOnInit:', error);
+            this.showError(AppMessages.FORM.ERROR.INIT);
+        }
+    }
+    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;
+        }
+        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']);
+        }
+        else {
+            console.log('[BaseFormComponent] No form data, loading from UUID');
+            this.loadFromUuid();
+        }
+    }
+    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);
+        });
+    }
+    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);
+        }
+        this.initializeFormData();
+    }
+    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();
+            }
+            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');
+                }
+                console.log('[BaseFormComponent] Form state after sync:', {
+                    valid: this.form.valid,
+                    values: this.form.value,
+                    currentData: this.currentFormData
+                });
+            }, 100);
+        }
+    }
+    initializeFormMode(routeMode) {
+        if (!routeMode) {
+            this.mode = AppConstants.PAGE_MODE.CREATE;
+        }
+        else if (this.isValidPageMode(routeMode)) {
+            this.mode = routeMode;
+        }
+        else {
+            throw new Error(`Invalid page mode: ${routeMode}`);
+        }
+    }
+    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;
+        }
+        if (this.mode === AppConstants.PAGE_MODE.VIEW) {
+            console.log('[BaseFormComponent] View mode setup');
+            this.form.disable();
+        }
+    }
+    getFormlyFieldConfig() {
+        return this.formlyConfigService.getFormConfig(this.getJsonFields(), this.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() {
+        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');
+        }
+    }
+    hasFormChanges(currentData) {
+        if (!this.originalFormData || this.isNew) {
+            return true;
+        }
+        console.log('[BaseFormComponent] Checking for changes:', {
+            currentData,
+            originalData: this.originalFormData
+        });
+        const hasChanges = 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;
+            }
+        });
+    }
+    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.4", 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.4", 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.4", ngImport: i0, type: BaseFormComponent });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BaseFormComponent, decorators: [{
+            type: Injectable
+        }, {
+            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;
+    rows = 10;
+    totalRecords = 0;
+    filters = [];
+    subscriptions = [];
+    constructor(router, notificationService, utilsService, confirmationService) {
+        super(utilsService, notificationService);
+        this.router = router;
+        this.notificationService = notificationService;
+        this.utilsService = utilsService;
+        this.confirmationService = confirmationService;
+    }
+    /**
+     * Initialize the component, subscribe to loading state if available,
+     * and load initial data.
+     */
+    ngOnInit() {
+        // Subscribe to loading state if available
+        const loadingObservable = this.getLoadingObservable();
+        if (loadingObservable) {
+            this.subscriptions.push(loadingObservable.subscribe(isLoading => this.loading = isLoading));
+        }
+        this.loadData();
+    }
+    /**
+     * Clean up any subscriptions when the component is destroyed
+     */
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+    /**
+     * Handle search event from the UI
+     * @param event The search event
+     */
+    onSearch(event) {
+        const element = event.target;
+        if (this.table) {
+            this.table.filterGlobal(element.value, 'contains');
+        }
+    }
+    /**
+     * 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
+     */
+    /**
+     * Convert PrimeNG filters to backend format with proper operator mapping
+     */
+    convertFilters(filters) {
+        const backendFilters = [];
+        if (!filters)
+            return backendFilters;
+        console.log('Raw PrimeNG filters:', filters);
+        Object.entries(filters).forEach(([key, filterMeta]) => {
+            console.log(`Processing filter for ${key}:`, filterMeta);
+            // Handle array of filter metadata (multiple filters for same column)
+            if (Array.isArray(filterMeta)) {
+                const validFilters = filterMeta
+                    .filter(meta => meta.value !== null && meta.value !== undefined && meta.value !== '')
+                    .map(meta => ({
+                    field: key,
+                    value: this.transformFilterValue(String(meta.value)),
+                    operator: this.transformOperator(meta.matchMode)
+                }));
+                backendFilters.push(...validFilters);
+            }
+            // Handle single filter metadata
+            else if (filterMeta?.value !== null && filterMeta?.value !== undefined && filterMeta?.value !== '') {
+                backendFilters.push({
+                    field: key,
+                    value: this.transformFilterValue(String(filterMeta.value)),
+                    operator: this.transformOperator(filterMeta.matchMode)
+                });
+            }
+        });
+        console.log('Converted filters:', backendFilters);
+        return backendFilters;
+    }
+    /**
+     * Transform filter value based on backend requirements - all values must be strings
+     */
+    transformFilterValue(value) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value.trim();
+        }
+        if (Array.isArray(value)) {
+            return value.join(',');
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return value.toString();
+        }
+        return String(value);
+    }
+    /**
+     * Map PrimeNG operators to backend operators
+     */
+    transformOperator(operator) {
+        const operatorMap = {
+            'contains': 'CONTAINS',
+            'startsWith': 'STARTS_WITH',
+            'endsWith': 'ENDS_WITH',
+            'equals': 'EQUALS',
+            'notEquals': 'NOT_EQUALS',
+            'gt': 'GREATER_THAN',
+            'gte': 'GREATER_THAN_EQUALS',
+            'lt': 'LESS_THAN',
+            'lte': 'LESS_THAN_EQUALS'
+        };
+        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() {
+        this.navigateTo([this.getFormRoute(), AppConstants.PAGE_MODE.CREATE]);
+    }
+    /**
+     * Navigate to view an entity
+     * @param item The entity to view
+     */
+    onView(item) {
+        if (!this.validateItemUuid(item, 'view'))
+            return;
+        this.navigateTo([this.getFormRoute(), AppConstants.PAGE_MODE.VIEW], { uuid: item.uuid });
+    }
+    /**
+     * Navigate to edit an entity
+     * @param item The entity to edit
+     */
+    onEdit(item) {
+        if (!this.validateItemUuid(item, 'edit'))
+            return;
+        this.navigateTo([this.getFormRoute(), AppConstants.PAGE_MODE.EDIT], { 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
+     */
+    getLoadingObservable() {
+        const service = this.getEntityService();
+        return service.loading$ || null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", 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.4", type: BaseListPageComponent, isStandalone: true, viewQueries: [{ propertyName: "table", first: true, predicate: ["dt"], descendants: true }], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BaseListPageComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1$2.Router }, { type: NotificationService }, { type: UtilsService }, { type: i1.ConfirmationService }], propDecorators: { table: [{
+                type: ViewChild,
+                args: ['dt']
+            }] } });
+
+class BaseTabbedFormComponent extends BasePageComponent {
+    route;
+    router;
+    notificationService;
+    utilsService;
+    // Tab specific properties
+    activeTab = '';
+    tabs = [];
+    formType = '';
+    // Form properties
+    isNew = true;
+    mode = AppConstants.PAGE_MODE.CREATE;
+    currentFormData;
+    originalFormData = null;
+    hasChanges = false;
+    debug(message, ...args) {
+        // Only log in development
+        if (process.env['NODE_ENV'] !== 'production') {
+            console.log(`[BaseTabbedFormComponent] ${message}`, ...args);
+        }
+    }
+    constructor(route, router, notificationService, utilsService) {
+        super(utilsService, notificationService);
+        this.route = route;
+        this.router = router;
+        this.notificationService = notificationService;
+        this.utilsService = utilsService;
+    }
+    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() {
+        this.debug('Initializing form data');
+        this.debug('Current mode:', this.mode);
+        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
+            this.debug('Create mode, using defaults');
+            this.loadDefaultTab();
+            return;
+        }
+        const state = {
+            ...this.router.getCurrentNavigation()?.extras?.state,
+            ...window.history.state
+        };
+        this.debug('Combined state:', state);
+        if (state?.formData) {
+            this.debug('Found form data in state:', state.formData);
+            this.patchFormData(state.formData);
+            this.loadDefaultTab();
+        }
+        else {
+            this.debug('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) {
+        // Remove debug logging for production
+        const routeMode = params[AppConstants.FORM.MODE];
+        try {
+            this.initializeFormMode(routeMode);
+            this.setupFormState();
+            if (this.formType === TabbedFormType.LIST) {
+                this.initializeListForm(params);
+            }
+            else {
+                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() {
+        this.debug('Setting up form state, mode:', this.mode);
+        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
+            this.debug('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;
+                this.debug('Original data loaded:', this.originalFormData);
+                this.debug('Form data updated:', this.currentFormData);
+                this.loadDefaultTab();
+            },
+            error: (error) => {
+                this.debug('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() {
+        this.debug('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);
+            this.router.navigate([defaultTab.value], {
+                relativeTo: this.route,
+                state: {
+                    formData: selectedData,
+                    formDataList: formDataList,
+                    context: ComponentContext.TABBED
+                }
+            });
+        }
+        else {
+            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];
+    }
+    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');
+        }
+        // Create tabs from list in state
+        this.tabs = formDataList.map((data) => ({
+            value: data.uuid,
+            title: this.getTabTitle(data),
+            isParentModel: true
+        }));
+        // Select tab based on UUID in params or first tab
+        const uuid = params[AppConstants.FORM.UUID];
+        this.activeTab = uuid && this.tabs.find(t => t.value === uuid)
+            ? uuid
+            : this.tabs[0].value;
+        // Set current form data from list
+        const selectedData = formDataList.find((d) => d.uuid === this.activeTab);
+        this.currentFormData = selectedData;
+        this.originalFormData = selectedData;
+    }
+    onTabChange(value) {
+        const tabConfig = this.findTabByValue(value);
+        if (!tabConfig) {
+            console.warn(`Tab not found: ${value}`);
+            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);
+            // Update current form data
+            this.currentFormData = selectedData;
+            this.originalFormData = selectedData;
+            this.router.navigate([value], {
+                relativeTo: this.route,
+                state: {
+                    formData: selectedData,
+                    formDataList: formDataList,
+                    context: ComponentContext.TABBED
+                }
+            });
+        }
+        else {
+            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.4", 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.4", 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.4", ngImport: i0, type: BaseTabbedFormComponent });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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.4", ngImport: i0, type: IndianDatePipe, deps: [{ token: i1$3.DatePipe }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.4", ngImport: i0, type: IndianDatePipe, isStandalone: true, name: "indianDate" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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.4", ngImport: i0, type: TextInputType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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.4", 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 || []);
+    }
+    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.4", ngImport: i0, type: SelectType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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.4", 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.4", ngImport: i0, type: RadioType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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.4", ngImport: i0, type: NumericInputType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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.4", 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.4", ngImport: i0, type: MultiselectType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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.4", ngImport: i0, type: DateType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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.4", 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.4", ngImport: i0, type: CheckboxType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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.4", 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.4", ngImport: i0, type: TextareaType, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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.4", ngImport: i0, type: FormFieldWrapper, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", 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.4", ngImport: i0, type: CoreFormlyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.4", ngImport: i0, type: CoreFormlyModule, imports: [i2.FormlyModule], exports: [FormlyModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.4", 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.4", 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]
+                }]
+        }] });
+
+// Config
+// Services
+
+/**
+ * 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 };
+//# sourceMappingURL=core-lib.mjs.map