@codex-ts/core-lib 1.0.0

package/dist/core-lib/lib/components/base-list-page.component.d.ts

@@ -0,0 +1,132 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { Table, TableLazyLoadEvent } from 'primeng/table';
+import { ConfirmationService } from 'primeng/api';
+import { NotificationService } from '../services/notification.service';
+import { Subscription, Observable } from 'rxjs';
+import { Page } from '../models/pagination/page.interface';
+import { PageRequest } from '../models/pagination/page-request.interface';
+import { FilterCriteria, FilterOperator } from '../models/pagination/filter-criteria.interface';
+import { BasePageComponent } from './base-page.component';
+import { UtilsService } from '../services/utils.service';
+import * as i0 from "@angular/core";
+/**
+ * Base component for all list page components in the application.
+ * Provides common functionality for list operations like loading data,
+ * pagination, sorting, and CRUD operations.
+ */
+export declare abstract class BaseListPageComponent<T extends {
+    uuid: string;
+}> extends BasePageComponent implements OnInit, OnDestroy {
+    protected router: Router;
+    protected notificationService: NotificationService;
+    protected utilsService: UtilsService;
+    protected confirmationService: ConfirmationService;
+    table: Table;
+    items: T[];
+    actionLoading: boolean;
+    rows: number;
+    totalRecords: number;
+    filters: FilterCriteria[];
+    protected subscriptions: Subscription[];
+    constructor(router: Router, notificationService: NotificationService, utilsService: UtilsService, confirmationService: ConfirmationService);
+    /**
+     * Initialize the component, subscribe to loading state if available,
+     * and load initial data.
+     */
+    ngOnInit(): void;
+    /**
+     * Clean up any subscriptions when the component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handle search event from the UI
+     * @param event The search event
+     */
+    onSearch(event: Event): void;
+    /**
+     * 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
+     */
+    protected convertFilters(filters: {
+        [key: string]: any;
+    }): FilterCriteria[];
+    /**
+     * Transform filter value based on backend requirements - all values must be strings
+     */
+    protected transformFilterValue(value: any): string;
+    /**
+     * Map PrimeNG operators to backend operators
+     */
+    protected transformOperator(operator: string): FilterOperator;
+    loadData(event?: TableLazyLoadEvent): void;
+    /**
+     * Navigate to create a new entity
+     */
+    onCreate(): void;
+    /**
+     * Navigate to view an entity
+     * @param item The entity to view
+     */
+    onView(item: T): void;
+    /**
+     * Navigate to edit an entity
+     * @param item The entity to edit
+     */
+    onEdit(item: T): void;
+    /**
+     * Navigate to a route with error handling
+     * @param path The route path
+     * @param matrixParams Optional matrix parameters
+     */
+    protected navigateTo(path: any[], matrixParams?: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Delete an entity with confirmation
+     * @param item The entity to delete
+     */
+    onDelete(item: T): void;
+    /**
+     * 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
+     */
+    protected validateItemUuid(item: T, action: string): boolean;
+    /**
+     * Get an observable for loading state from the entity service
+     * @returns An observable of loading state if available, null otherwise
+     */
+    protected getLoadingObservable(): Observable<boolean> | null;
+    /**
+     * Get the entity service for data operations
+     */
+    protected abstract getEntityService(): {
+        getAll: (pageRequest?: PageRequest) => Observable<Page<T>>;
+        delete: (uuid: string) => Observable<any>;
+    };
+    /**
+     * Get the entity name for display in messages
+     */
+    protected abstract getEntityName(): string;
+    /**
+     * Get the route to the entity form
+     */
+    protected abstract getFormRoute(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseListPageComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseListPageComponent<any>, never, never, {}, {}, never, never, true, never>;
+}

package/dist/core-lib/lib/components/base-page.component.d.ts

@@ -0,0 +1,25 @@
+import { UtilsService } from '../services/utils.service';
+import { NotificationService } from '../services/notification.service';
+import * as i0 from "@angular/core";
+/**
+ * Base component for all page components in the application.
+ * Provides common functionality like loading state and message display.
+ */
+export declare abstract class BasePageComponent {
+    protected utilsService: UtilsService;
+    protected notificationService: NotificationService;
+    protected loading: boolean;
+    constructor(utilsService: UtilsService, notificationService: NotificationService);
+    /**
+     * Display an error message to the user
+     * @param detail The error message to display
+     */
+    protected showError(detail: string): void;
+    /**
+     * Display a success message to the user
+     * @param detail The success message to display
+     */
+    protected showSuccess(detail: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasePageComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BasePageComponent, never, never, {}, {}, never, never, true, never>;
+}

package/dist/core-lib/lib/components/base-tabbed-form.component.d.ts

@@ -0,0 +1,54 @@
+import { OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { BasePageComponent } from './base-page.component';
+import { UtilsService } from '../services/utils.service';
+import { NotificationService } from '../services/notification.service';
+import { PageMode } from '../constants/app.constants';
+import { EntityService } from '../services/entity.service';
+import * as i0 from "@angular/core";
+export interface TabConfig {
+    value: string;
+    title: string;
+    isParentModel?: boolean;
+}
+export declare abstract class BaseTabbedFormComponent<T extends {
+    uuid: string;
+}> extends BasePageComponent implements OnInit {
+    protected route: ActivatedRoute;
+    protected router: Router;
+    protected notificationService: NotificationService;
+    protected utilsService: UtilsService;
+    activeTab: string;
+    tabs: TabConfig[];
+    formType: string;
+    isNew: boolean;
+    mode: PageMode;
+    currentFormData: T;
+    protected originalFormData: T | null;
+    protected hasChanges: boolean;
+    private debug;
+    constructor(route: ActivatedRoute, router: Router, notificationService: NotificationService, utilsService: UtilsService);
+    ngOnInit(): void;
+    private initializeFormData;
+    private loadFromUuid;
+    private initializeForm;
+    protected patchFormData(data: T | null): void;
+    private initializeFormMode;
+    private setupFormState;
+    protected loadEntity(uuid: string): void;
+    protected findTabByValue(value: string): TabConfig | undefined;
+    protected loadDefaultTab(): void;
+    protected getTabFormData(tabConfig: TabConfig): T | null;
+    private initializeListForm;
+    protected onTabChange(value: string | number): void;
+    protected hasFormChanges(currentData: T): boolean;
+    private isEqual;
+    private isValidPageMode;
+    protected abstract getTabs(): TabConfig[];
+    protected abstract getEntityService(): EntityService<T>;
+    protected abstract getEntityName(): string;
+    protected abstract getTabTitle(data: T): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTabbedFormComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseTabbedFormComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseTabbedFormComponent<any>>;
+}

package/dist/core-lib/lib/components/formly/core-formly.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-formly/core";
+export declare class CoreFormlyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreFormlyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreFormlyModule, never, [typeof i1.FormlyModule], [typeof i1.FormlyModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreFormlyModule>;
+}

package/dist/core-lib/lib/components/formly/form-field.wrapper.d.ts

@@ -0,0 +1,21 @@
+import { FieldWrapper, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+interface FormlyValidationMessage {
+    [key: string]: string;
+}
+interface FormlyFieldProps {
+    label?: string;
+    required?: boolean;
+    tooltip?: string;
+    description?: string;
+    validation?: {
+        messages?: FormlyValidationMessage;
+    };
+}
+export declare class FormFieldWrapper extends FieldWrapper<FormlyFieldConfig<FormlyFieldProps>> {
+    get errorMessage(): string;
+    get showError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldWrapper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldWrapper, "formly-wrapper-form-field", never, {}, {}, never, never, true, never>;
+}
+export {};

package/dist/core-lib/lib/components/formly/formly.constants.d.ts

@@ -0,0 +1,13 @@
+export declare const FORMLY_TYPES: {
+    TEXT: string;
+    NUMBER: string;
+    DATE: string;
+    CHECKBOX: string;
+    RADIO: string;
+    SELECT: string;
+    MULTISELECT: string;
+    TEXTAREA: string;
+};
+export declare const FORMLY_WRAPPERS: {
+    FORM_FIELD: string;
+};

package/dist/core-lib/lib/components/formly/types/checkbox.type.d.ts

@@ -0,0 +1,12 @@
+import { FieldType } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+export declare class CheckboxType extends FieldType {
+    defaultOptions: {
+        props: {
+            trueValue: boolean;
+            falseValue: boolean;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxType, "formly-field-checkbox", never, {}, {}, never, never, true, never>;
+}

package/dist/core-lib/lib/components/formly/types/date.type.d.ts

@@ -0,0 +1,20 @@
+import { FieldType } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+export declare class DateType extends FieldType {
+    defaultOptions: {
+        props: {
+            dateFormat: string;
+            showTime: boolean;
+            touchUI: boolean;
+            placeholder: string;
+            showButtonBar: boolean;
+        };
+    };
+    onDateSelect(event: Date): void;
+    onDateInput(event: any): void;
+    private formatAndSetDate;
+    private parseDate;
+    private isValidDateInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateType, "formly-field-date", never, {}, {}, never, never, true, never>;
+}

package/dist/core-lib/lib/components/formly/types/multiselect.type.d.ts

@@ -0,0 +1,26 @@
+import { FieldType } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface SelectOption {
+    value: any;
+    label: string;
+    [key: string]: any;
+}
+export declare class MultiselectType extends FieldType {
+    get options$(): Observable<SelectOption[]>;
+    defaultOptions: {
+        props: {
+            options: SelectOption[];
+            optionLabel: string;
+            optionValue: string;
+            placeholder: string;
+            filter: boolean;
+            maxSelectedLabels: number;
+            showToggleAll: boolean;
+            virtualScroll: boolean;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiselectType, "formly-field-multiselect", never, {}, {}, never, never, true, never>;
+}
+export {};

package/dist/core-lib/lib/components/formly/types/numeric-input.type.d.ts

@@ -0,0 +1,17 @@
+import { FieldType } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+export declare class NumericInputType extends FieldType {
+    defaultOptions: {
+        props: {
+            min: any;
+            max: any;
+            minFractionDigits: number;
+            maxFractionDigits: number;
+            prefix: string;
+            suffix: string;
+            useGrouping: boolean;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumericInputType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumericInputType, "formly-field-numeric-input", never, {}, {}, never, never, true, never>;
+}

package/dist/core-lib/lib/components/formly/types/radio.type.d.ts

@@ -0,0 +1,13 @@
+import { FieldType } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface RadioOption {
+    value: any;
+    label: string;
+}
+export declare class RadioType extends FieldType {
+    get options$(): Observable<RadioOption[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioType, "formly-field-radio", never, {}, {}, never, never, true, never>;
+}
+export {};

package/dist/core-lib/lib/components/formly/types/select.type.d.ts

@@ -0,0 +1,25 @@
+import { FieldType } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface SelectOption {
+    value: any;
+    label: string;
+    [key: string]: any;
+}
+export declare class SelectType extends FieldType {
+    get options$(): Observable<SelectOption[]>;
+    defaultOptions: {
+        props: {
+            options: any[];
+            optionLabel: string;
+            optionValue: string;
+            placeholder: string;
+            showClear: boolean;
+            filter: boolean;
+            virtualScroll: boolean;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectType, "formly-field-select", never, {}, {}, never, never, true, never>;
+}
+export {};

package/dist/core-lib/lib/components/formly/types/text-input.type.d.ts

@@ -0,0 +1,12 @@
+import { FieldType } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+export declare class TextInputType extends FieldType {
+    defaultOptions: {
+        props: {
+            type: string;
+            placeholder: string;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextInputType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextInputType, "formly-field-text-input", never, {}, {}, never, never, true, never>;
+}

package/dist/core-lib/lib/components/formly/types/textarea.type.d.ts

@@ -0,0 +1,14 @@
+import { FieldType } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+export declare class TextareaType extends FieldType {
+    defaultOptions: {
+        props: {
+            rows: number;
+            cols: any;
+            autoResize: boolean;
+            placeholder: string;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaType, "formly-field-textarea", never, {}, {}, never, never, true, never>;
+}

package/dist/core-lib/lib/constants/app.constants.d.ts

@@ -0,0 +1,13 @@
+export declare class AppConstants {
+    static readonly FORM: {
+        readonly MODE: "mode";
+        readonly UUID: "uuid";
+        readonly NEW: "new";
+    };
+    static readonly PAGE_MODE: {
+        readonly CREATE: "create";
+        readonly EDIT: "edit";
+        readonly VIEW: "view";
+    };
+}
+export type PageMode = typeof AppConstants.PAGE_MODE[keyof typeof AppConstants.PAGE_MODE];

package/dist/core-lib/lib/constants/app.messages.d.ts

@@ -0,0 +1,36 @@
+export declare const AppMessages: {
+    readonly COMMON: {
+        readonly ERROR: {
+            readonly GENERAL: "An error occurred";
+            readonly INVALID_INPUT: "Invalid input provided";
+            readonly REQUIRED_FIELD: "This field is required";
+        };
+        readonly SUCCESS: {
+            readonly SAVE: "saved successfully";
+            readonly UPDATE: "updated successfully";
+            readonly DELETE: "deleted successfully";
+        };
+    };
+    readonly FORM: {
+        readonly ERROR: {
+            readonly INIT: "Failed to initialize form";
+            readonly SAVE: "Failed to save";
+            readonly LOAD: "Failed to load";
+            readonly VALIDATION: "Please fill in all required fields correctly";
+        };
+        readonly SUCCESS: {
+            readonly SAVE: "saved successfully";
+        };
+    };
+    readonly LIST: {
+        readonly ERROR: {
+            readonly LOAD: "Failed to load";
+            readonly DELETE: "Failed to delete";
+            readonly NAVIGATION: "Navigation failed";
+            readonly INVALID_ID: "Cannot perform action without ID";
+        };
+        readonly SUCCESS: {
+            readonly DELETE: "deleted successfully";
+        };
+    };
+};

package/dist/core-lib/lib/enums/component-context.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum ComponentContext {
+    STANDALONE = "STANDALONE",
+    TABBED = "TABBED",
+    MODAL = "MODAL",
+    EMBEDDED = "EMBEDDED"
+}

package/dist/core-lib/lib/enums/tabbed-form-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum TabbedFormType {
+    STANDARD = "STANDARD",
+    LIST = "LIST"
+}

package/dist/core-lib/lib/models/pagination/filter-criteria.interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Matches backend FilterCriteria and FilterOperator
+ */
+export type FilterOperator = 'EQUALS' | 'NOT_EQUALS' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'LESS_THAN' | 'LESS_THAN_EQUALS' | 'GREATER_THAN' | 'GREATER_THAN_EQUALS';
+export interface FilterCriteria {
+    field: string;
+    value: string;
+    operator: FilterOperator;
+}

package/dist/core-lib/lib/models/pagination/page-request.interface.d.ts

@@ -0,0 +1,10 @@
+import { FilterCriteria } from './filter-criteria.interface';
+import { SortCriteria } from './sort-criteria.interface';
+export interface PageRequest {
+    page?: number;
+    size?: number;
+    sorts?: SortCriteria[];
+    filters?: FilterCriteria[];
+}
+export type { FilterCriteria } from './filter-criteria.interface';
+export type { SortCriteria } from './sort-criteria.interface';

package/dist/core-lib/lib/models/pagination/page.interface.d.ts

@@ -0,0 +1,9 @@
+export interface Page<T> {
+    content: T[];
+    page: {
+        totalElements: number;
+        totalPages: number;
+        size: number;
+        number: number;
+    };
+}

package/dist/core-lib/lib/models/pagination/sort-criteria.interface.d.ts

@@ -0,0 +1,4 @@
+export interface SortCriteria {
+    field: string;
+    direction: 'asc' | 'desc';
+}

package/dist/core-lib/lib/pipes/indian-date.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from '@angular/core';
+import { DatePipe } from '@angular/common';
+import * as i0 from "@angular/core";
+type DateFormat = 'default' | 'short' | 'medium';
+export declare class IndianDatePipe implements PipeTransform {
+    private datePipe;
+    constructor(datePipe: DatePipe);
+    transform(value: string | null, format?: DateFormat): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndianDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IndianDatePipe, "indianDate", true>;
+}
+export {};

package/dist/core-lib/lib/services/base-crud.service.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { HttpUtilityService } from './http-utility.service';
+import { UtilsService } from './utils.service';
+import { MessageService } from 'primeng/api';
+import { Page } from '../models/pagination/page.interface';
+import { PageRequest } from '../models/pagination/page-request.interface';
+import { EntityService } from './entity.service';
+export declare abstract class BaseCrudService<T extends {
+    uuid: string;
+}> implements EntityService<T> {
+    protected httpUtility: HttpUtilityService;
+    protected utilsService: UtilsService;
+    protected resourcePath: string;
+    protected backendBaseUrl: string;
+    protected messageService: MessageService | undefined;
+    get loading$(): Observable<boolean>;
+    protected apiUrl: string;
+    /**
+     * 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
+     */
+    protected constructor(httpUtility: HttpUtilityService, utilsService: UtilsService, resourcePath: string, backendBaseUrl: string, messageService: MessageService | undefined);
+    /**
+     * Joins URL parts ensuring no double slashes
+     */
+    private joinUrls;
+    getAll(pageRequest?: PageRequest): Observable<Page<T>>;
+    getById(uuid: string): Observable<T>;
+    create(entity: Omit<T, 'uuid'>): Observable<T>;
+    update(uuid: string, entity: Omit<T, 'uuid'>): Observable<T>;
+    delete(uuid: string): Observable<void>;
+}

package/dist/core-lib/lib/services/entity-registry.service.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import { HttpUtilityService } from './http-utility.service';
+import { ReferenceDataProviderService } from './reference-data-provider.service';
+import * as i0 from "@angular/core";
+export interface ReferenceDto {
+    key: string;
+    displayLabel: string;
+    data?: any;
+}
+export declare class EntityRegistryService {
+    private httpUtility;
+    private dataProvider;
+    constructor(httpUtility: HttpUtilityService, dataProvider: ReferenceDataProviderService);
+    /**
+     * 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: string): Observable<{
+        label: string;
+        value: string;
+        data?: any;
+    }[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityRegistryService>;
+}

package/dist/core-lib/lib/services/entity.service.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+/**
+ * Interface for basic CRUD operations that all entity services must implement
+ */
+export interface EntityService<T> {
+    create(data: Omit<T, 'uuid'>): Observable<T>;
+    update(uuid: string, data: Omit<T, 'uuid'>): Observable<T>;
+    getById(uuid: string): Observable<T>;
+}

package/dist/core-lib/lib/services/enum-registry.service.d.ts

@@ -0,0 +1,41 @@
+import { UtilsService } from './utils.service';
+import * as i0 from "@angular/core";
+export declare class EnumRegistryService {
+    private utilsService;
+    private enumMap;
+    constructor(utilsService: UtilsService);
+    /**
+     * Initialize global enums
+     */
+    static registerGlobalEnums(enums: Record<string, any>): {
+        provide: typeof EnumRegistryService;
+        useFactory: (utilsService: UtilsService) => EnumRegistryService;
+        deps: (typeof 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: string, enumType: any): void;
+    /**
+     * 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: string): {
+        label: string;
+        value: string;
+    }[];
+    /**
+     * Check if an enum type is registered
+     * @param name Name of the enum to check
+     */
+    hasEnum(name: string): boolean;
+    /**
+     * Clear all registered enums
+     */
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnumRegistryService>;
+}

package/dist/core-lib/lib/services/formly-config.service.d.ts

@@ -0,0 +1,11 @@
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { PageMode } from '../constants/app.constants';
+import { EnumRegistryService } from './enum-registry.service';
+import * as i0 from "@angular/core";
+export declare class FormlyConfigService {
+    private enumRegistry;
+    constructor(enumRegistry: EnumRegistryService);
+    getFormConfig(fields: FormlyFieldConfig[], mode: PageMode, dynamicOptions?: Record<string, any>): FormlyFieldConfig[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormlyConfigService>;
+}