@es.framework/ng.ui.core 2.0.58

package/types/es.framework-ng.ui.core-column-settings-popover.d.ts

@@ -0,0 +1,46 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, EventEmitter, SimpleChanges } from '@angular/core';
+import * as i1 from '@angular/common';
+import { ColumnDef } from '@es.framework/ng.core/models';
+import { LocalizationService } from '@es.framework/ng.core/services';
+
+declare class ColumnSettingsPopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnSettingsPopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ColumnSettingsPopoverModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ColumnSettingsPopoverModule>;
+}
+
+type PopoverColumnDef<T> = ColumnDef<T> & {
+    isSelected?: boolean;
+};
+declare class ColumnSettingsPopoverComponent<T extends {
+    [key: string]: any;
+}> implements OnInit, OnChanges {
+    private translate;
+    op: any;
+    fixedColumns: ColumnDef<T>[];
+    toggleableColumns: ColumnDef<T>[];
+    tableId: string;
+    _displayOrderListColumns: PopoverColumnDef<T>[];
+    private _selectedToggleableColumns;
+    get selectedToggleableColumns(): ColumnDef<T>[];
+    set selectedToggleableColumns(val: ColumnDef<T>[]);
+    selectedToggleableColumnsChange: EventEmitter<ColumnDef<T>[]>;
+    constructor(translate: LocalizationService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    get allColumnsSelected(): boolean;
+    set allColumnsSelected(value: boolean);
+    private initializeDisplayColumns;
+    private syncDisplayColumnsWithSelectedInput;
+    toggle(event: Event): void;
+    hide(): void;
+    onColumnVisibilityChange(column: PopoverColumnDef<T>): void;
+    onOrderListReorder(event: any): void;
+    private emitCurrentSelection;
+    private areColumnsEqual;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnSettingsPopoverComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnSettingsPopoverComponent<any>, "lib-column-settings-popover", never, { "fixedColumns": { "alias": "fixedColumns"; "required": false; }; "toggleableColumns": { "alias": "toggleableColumns"; "required": false; }; "tableId": { "alias": "tableId"; "required": false; }; "selectedToggleableColumns": { "alias": "selectedToggleableColumns"; "required": false; }; }, { "selectedToggleableColumnsChange": "selectedToggleableColumnsChange"; }, never, never, true, never>;
+}
+
+export { ColumnSettingsPopoverComponent, ColumnSettingsPopoverModule };

package/types/es.framework-ng.ui.core-custom-switch.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit } from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType, FieldTypeConfig } from '@ngx-formly/core';
+
+declare class CustomSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CustomSwitchModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CustomSwitchModule>;
+}
+
+declare class CustomSwitchFieldComponent extends FieldType<FieldTypeConfig> implements AfterViewInit {
+    updateModel(value: boolean): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomSwitchFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CustomSwitchFieldComponent, "formly-field-custom-switch", never, {}, {}, never, never, true, never>;
+}
+
+export { CustomSwitchFieldComponent, CustomSwitchModule };

package/types/es.framework-ng.ui.core-datepicker.d.ts

@@ -0,0 +1,23 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i5 from '@ngx-formly/core';
+import { ConfigOption } from '@ngx-formly/core';
+import * as i2 from '@angular/forms';
+import * as i3 from 'primeng/datepicker';
+import * as i4 from '@es.framework/ng.ui.core/form-field';
+
+declare class DatepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DatepickerModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DatepickerModule>;
+}
+
+declare function withFormlyFieldDatepicker(): ConfigOption;
+
+declare class FormlyDatepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyDatepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyDatepickerModule, never, [typeof i1.CommonModule, typeof i2.ReactiveFormsModule, typeof i3.DatePickerModule, typeof i4.FormlyFormFieldModule, typeof i5.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyDatepickerModule>;
+}
+
+export { DatepickerModule, FormlyDatepickerModule, withFormlyFieldDatepicker };

package/types/es.framework-ng.ui.core-deactivation-reason.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import * as i1 from '@angular/common';
+import { FormGroup } from '@angular/forms';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+
+declare class DeactivationReasonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeactivationReasonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DeactivationReasonModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DeactivationReasonModule>;
+}
+
+declare class DeactivationReasonFormComponent implements OnDestroy {
+    ref: DynamicDialogRef;
+    config: DynamicDialogConfig;
+    form: FormGroup<{}>;
+    model: any;
+    fields: FormlyFieldConfig[];
+    loading: boolean;
+    errorMessage: string | null;
+    private destroy$;
+    private idField;
+    private idParser;
+    constructor(ref: DynamicDialogRef, config: DynamicDialogConfig);
+    onSubmit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeactivationReasonFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DeactivationReasonFormComponent, "app-deactivation-reason-form", never, {}, {}, never, never, true, never>;
+}
+
+export { DeactivationReasonFormComponent, DeactivationReasonModule };

package/types/es.framework-ng.ui.core-excel-import.d.ts

@@ -0,0 +1,69 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter } from '@angular/core';
+import * as i1 from '@angular/common';
+import { FormGroup } from '@angular/forms';
+import { EnvironmentService } from '@es.framework/ng.core/services';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+
+declare class ExcelImportModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExcelImportModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExcelImportModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExcelImportModule>;
+}
+
+interface ExcelImportConfig {
+    templateUrl: string;
+    apiUrl: string;
+    apiName: string;
+    mappingFields: FormlyFieldConfig[];
+    acceptedFileTypes?: string;
+    maxFileSize?: number;
+    steps?: {
+        label: string;
+    }[];
+}
+declare class ExcelImportComponent implements OnDestroy {
+    ref: DynamicDialogRef;
+    dialogConfig: DynamicDialogConfig;
+    config: ExcelImportConfig;
+    importComplete: EventEmitter<any>;
+    importError: EventEmitter<Error>;
+    form: FormGroup;
+    model: any;
+    loading: boolean;
+    uploadedFileName: string | null;
+    uploadError: string | null;
+    excelHeaders: string[];
+    private destroy$;
+    private restService;
+    private messageService;
+    private translateService;
+    private fb;
+    env: EnvironmentService;
+    steps: {
+        label: string;
+    }[];
+    activeStep: number;
+    mappingFields: FormlyFieldConfig[];
+    constructor(ref: DynamicDialogRef, dialogConfig: DynamicDialogConfig);
+    ngOnInit(): void;
+    nextStep(): void;
+    prevStep(): void;
+    canProceed(): boolean;
+    getModelValue(field: FormlyFieldConfig, model: any): any;
+    private fileContent;
+    onFileUpload(event: any): void;
+    private arrayBufferToBase64;
+    private getFileExtension;
+    onSubmit(): void;
+    private clearFileUpload;
+    private initializeForm;
+    onCancel(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExcelImportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExcelImportComponent, "app-excel-import", never, { "config": { "alias": "config"; "required": false; }; }, { "importComplete": "importComplete"; "importError": "importError"; }, never, never, true, never>;
+}
+
+export { ExcelImportComponent, ExcelImportModule };
+export type { ExcelImportConfig };

package/types/es.framework-ng.ui.core-filter-templates.d.ts

@@ -0,0 +1,57 @@
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import * as i1 from '@angular/common';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { BaseService } from '@es.framework/ng.core/services';
+
+declare class FilterTemplatesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTemplatesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FilterTemplatesModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FilterTemplatesModule>;
+}
+
+type FilterTemplateDefaults = {
+    defaultPermission?: string;
+    defaultModule?: string;
+    defaultService?: string;
+    defaultFeature?: string;
+};
+declare function FilterTemplateFormFields(filterFields?: FormlyFieldConfig[], defaults?: FilterTemplateDefaults): FormlyFieldConfig[];
+
+type EditorMode = 'create' | 'edit';
+declare class FilterTemplateEditorDialogComponent {
+    svc: BaseService;
+    form: UntypedFormGroup;
+    /** فتح/إغلاق */
+    visible: boolean;
+    visibleChange: EventEmitter<boolean>;
+    /** وضع المكون */
+    mode: EditorMode;
+    /** نموذج القالب */
+    model: any;
+    /** حقول query builder */
+    filterFields: FormlyFieldConfig[];
+    /** API */
+    apiName: string;
+    moduleName: string;
+    idField: string;
+    /** Defaults */
+    defaultFeature: string;
+    defaultPermission: string;
+    defaultCategory: string;
+    /** UI */
+    dialogMaxWidth: string;
+    /** Events */
+    saved: EventEmitter<any>;
+    currentUserId: string | null;
+    get computedFields(): FormlyFieldConfig[];
+    beforeSaveTransform: (record: any) => any;
+    onVisibleChange(v: boolean): void;
+    onAfterSave(e: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTemplateEditorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterTemplateEditorDialogComponent, "filter-template-editor-dialog", never, { "visible": { "alias": "visible"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "model": { "alias": "model"; "required": false; }; "filterFields": { "alias": "filterFields"; "required": false; }; "apiName": { "alias": "apiName"; "required": false; }; "moduleName": { "alias": "moduleName"; "required": false; }; "idField": { "alias": "idField"; "required": false; }; "defaultFeature": { "alias": "defaultFeature"; "required": false; }; "defaultPermission": { "alias": "defaultPermission"; "required": false; }; "defaultCategory": { "alias": "defaultCategory"; "required": false; }; "dialogMaxWidth": { "alias": "dialogMaxWidth"; "required": false; }; "currentUserId": { "alias": "currentUserId"; "required": false; }; }, { "visibleChange": "visibleChange"; "saved": "saved"; }, never, never, true, never>;
+}
+
+export { FilterTemplateEditorDialogComponent, FilterTemplateFormFields, FilterTemplatesModule };
+export type { FilterTemplateDefaults };

package/types/es.framework-ng.ui.core-form-button.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType } from '@ngx-formly/core';
+
+declare class FormButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormButtonModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormButtonModule>;
+}
+
+declare class FormlyFieldButton extends FieldType {
+    onClick($event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldButton, "formly-field-button", never, {}, {}, never, never, true, never>;
+}
+
+export { FormButtonModule, FormlyFieldButton };

package/types/es.framework-ng.ui.core-form-field.d.ts

@@ -0,0 +1,30 @@
+import * as i4 from '@ngx-formly/core';
+import { ConfigOption, FormlyFieldProps as FormlyFieldProps$1, FieldWrapper, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i5 from '@es.framework/ng.core/pipes';
+
+declare function withFormlyFormField(): ConfigOption;
+
+interface FormlyFieldProps extends FormlyFieldProps$1 {
+    hideRequiredMarker?: boolean;
+    hideLabel?: boolean;
+}
+declare class FormlyWrapperFormField extends FieldWrapper<FormlyFieldConfig<FormlyFieldProps>> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyWrapperFormField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyWrapperFormField, "formly-wrapper-primeng-form-field", never, {}, {}, never, never, false, never>;
+}
+declare class FormlyWrapperFormFieldNo extends FieldWrapper<FormlyFieldConfig<FormlyFieldProps>> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyWrapperFormFieldNo, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyWrapperFormFieldNo, "formly-wrapper-primeng-form-field-no", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyFormFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFormFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyFormFieldModule, [typeof FormlyWrapperFormField, typeof FormlyWrapperFormFieldNo], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.FormlyModule, typeof i5.TranslatePipe], [typeof FormlyWrapperFormField]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyFormFieldModule>;
+}
+
+export { FormlyFormFieldModule, FormlyWrapperFormField, withFormlyFormField };
+export type { FormlyFieldProps };

package/types/es.framework-ng.ui.core-form-template.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType } from '@ngx-formly/core';
+
+declare class FormTemplateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormTemplateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormTemplateModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormTemplateModule>;
+}
+
+declare class FormlyTemplateType extends FieldType {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyTemplateType, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyTemplateType, "formly-template", never, {}, {}, never, never, true, never>;
+}
+
+export { FormTemplateModule, FormlyTemplateType };

package/types/es.framework-ng.ui.core-formly-avatar-image.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType, FieldTypeConfig } from '@ngx-formly/core';
+
+declare class FormlyAvatarImageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyAvatarImageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyAvatarImageModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyAvatarImageModule>;
+}
+
+declare class FormlyAvatarImageComponent extends FieldType<FieldTypeConfig> {
+    get type(): string;
+    get displayValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyAvatarImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyAvatarImageComponent, "formly-field-avatar-image", never, {}, {}, never, never, true, never>;
+}
+
+export { FormlyAvatarImageComponent, FormlyAvatarImageModule };

package/types/es.framework-ng.ui.core-formly-avatar-label.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType } from '@ngx-formly/core';
+
+declare class FormlyAvatarLabelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyAvatarLabelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyAvatarLabelModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyAvatarLabelModule>;
+}
+
+interface AvatarLabelProps {
+    /**
+     * The username or display name, shown as text and used for avatar initial
+     */
+    username?: string;
+    /**
+     * Prefix label shown before username (e.g. "FROM"), expected to be a translatable key
+     */
+    prefixLabel?: string;
+    /**
+     * Additional CSS classes to customize wrapper div if needed
+     */
+    styleClass?: string;
+    /**
+     * Whether the button should be disabled (optional)
+     */
+    disabled?: boolean;
+    showUsername?: boolean;
+}
+declare class FormlyAvatarLabelComponent extends FieldType {
+    get to(): AvatarLabelProps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyAvatarLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyAvatarLabelComponent, "formly-avatar-label", never, {}, {}, never, never, true, never>;
+}
+
+export { FormlyAvatarLabelComponent, FormlyAvatarLabelModule };

package/types/es.framework-ng.ui.core-formly-button-selector.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType, FieldTypeConfig } from '@ngx-formly/core';
+import { Popover } from 'primeng/popover';
+import { LocalizationService } from '@es.framework/ng.core/services';
+
+declare class FormlyButtonSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyButtonSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyButtonSelectorModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyButtonSelectorModule>;
+}
+
+interface SelectionButtonProps {
+    options?: any[];
+    optionLabel: string;
+    optionValue: string;
+    popoverHeader?: string;
+    buttonLabel?: string;
+    buttonIcon?: string;
+    onSelect?: (value: any) => void;
+}
+declare class FormlySelectionButtonComponent extends FieldType<FieldTypeConfig<SelectionButtonProps>> implements OnInit {
+    private translate;
+    popover: Popover;
+    constructor(translate: LocalizationService);
+    getButtonLabel(): string;
+    getButtonIcon(): string | undefined;
+    onSelect(value: any): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlySelectionButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlySelectionButtonComponent, "formly-selection-button", never, {}, {}, never, never, true, never>;
+}
+
+export { FormlyButtonSelectorModule, FormlySelectionButtonComponent };

package/types/es.framework-ng.ui.core-formly-button.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType } from '@ngx-formly/core';
+
+declare class FormlyButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyButtonModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyButtonModule>;
+}
+
+interface TemplateOptions {
+    onExpand?: (field: any, model: any) => void;
+}
+declare class FormlyButtonComponent extends FieldType {
+    get to(): TemplateOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyButtonComponent, "formly-button", never, {}, {}, never, never, true, never>;
+}
+
+export { FormlyButtonComponent, FormlyButtonModule };

package/types/es.framework-ng.ui.core-formly-presets.d.ts

@@ -0,0 +1,37 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+
+declare class FormlyPresetsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyPresetsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyPresetsModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyPresetsModule>;
+}
+
+declare const DEFAULT_CONTROL_CLASS: string;
+interface SelectOption {
+    label: string;
+    value: any;
+    icon?: string;
+}
+declare function numberField(key: string, label: string, required?: boolean, className?: string): FormlyFieldConfig;
+declare function textField(key: string, label: string, required?: boolean, className?: string, extraTemplateOptions?: {
+    [key: string]: any;
+}): FormlyFieldConfig;
+declare function textField2(key: string, label: string, required?: boolean, className?: string, expressions?: FormlyFieldConfig['expressions']): FormlyFieldConfig;
+declare function textareaField(key: string, label: string, rows?: number, className?: string): FormlyFieldConfig;
+interface SelectFieldOptions {
+    key: string;
+    label: string;
+    options?: SelectOption[] | Observable<SelectOption[]>;
+    className?: string;
+    defaultValue?: any;
+    required?: boolean;
+    fullWidth?: boolean;
+}
+declare function selectField({ key, label, options, className, defaultValue, fullWidth, required, }: SelectFieldOptions): FormlyFieldConfig;
+declare function checkboxField(key: string, label: string, required?: boolean, className?: string): FormlyFieldConfig;
+
+export { DEFAULT_CONTROL_CLASS, FormlyPresetsModule, checkboxField, numberField, selectField, textField, textField2, textareaField };
+export type { SelectFieldOptions, SelectOption };

package/types/es.framework-ng.ui.core-formly-prime-icon-picker.d.ts

@@ -0,0 +1,45 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType } from '@ngx-formly/core';
+import { Popover } from 'primeng/popover';
+
+declare class FormlyPrimeIconPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyPrimeIconPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyPrimeIconPickerModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyPrimeIconPickerModule>;
+}
+
+type IconCategory = 'navigation' | 'actions' | 'files' | 'ui' | 'social' | 'status' | 'charts';
+interface IconDef {
+    class: string;
+    name: string;
+    category: IconCategory;
+}
+declare class PrimeIconPickerComponent extends FieldType {
+    popover?: Popover;
+    searchQuery: string;
+    selectedCategory: IconCategory | '';
+    filtered: IconDef[];
+    primeIcons: IconDef[];
+    categories: {
+        label: string;
+        value: IconCategory | '';
+    }[];
+    private iconByClass;
+    ngOnInit(): void;
+    get selectedIconClass(): string;
+    get selectedIconName(): string;
+    togglePopover(event: Event): void;
+    selectCategory(category: IconCategory | ''): void;
+    applyFilters(): void;
+    onIconClick(icon: IconDef, event: Event): void;
+    trackIcon: (_: number, icon: IconDef) => string;
+    trackCategory: (_: number, cat: {
+        label: string;
+        value: IconCategory | "";
+    }) => IconCategory | "all";
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrimeIconPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrimeIconPickerComponent, "formly-field-prime-icon-picker", never, {}, {}, never, never, true, never>;
+}
+
+export { FormlyPrimeIconPickerModule, PrimeIconPickerComponent };

package/types/es.framework-ng.ui.core-formly-split-button.d.ts

@@ -0,0 +1,23 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType, FieldTypeConfig } from '@ngx-formly/core';
+import { MenuItem } from 'primeng/api';
+
+declare class FormlySplitButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlySplitButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlySplitButtonModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlySplitButtonModule>;
+}
+
+interface SplitButtonProps {
+    label: string;
+    icon?: string;
+    items: MenuItem[];
+    onClick?: () => void;
+}
+declare class FormlySplitButtonComponent extends FieldType<FieldTypeConfig<SplitButtonProps>> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlySplitButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlySplitButtonComponent, "formly-split-button-type", never, {}, {}, never, never, true, never>;
+}
+
+export { FormlySplitButtonComponent, FormlySplitButtonModule };

package/types/es.framework-ng.ui.core-formly-ui-all.d.ts

@@ -0,0 +1,40 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { ConfigOption } from '@ngx-formly/core';
+
+declare class FormlyUiAllModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyUiAllModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyUiAllModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyUiAllModule>;
+}
+
+declare function provideAllFormlyFields(): ConfigOption[];
+declare function withFormlyQueryBuilder(): ConfigOption;
+declare function withFormlyFieldInputWithIcon(): ConfigOption;
+declare function withFormlyFieldAttachment(): ConfigOption;
+declare function withFormlyFieldRichTextEditor(): ConfigOption;
+declare function withFormlyFieldGenericSelector(): ConfigOption;
+declare function globalGenericSelectorExtension(): ConfigOption;
+declare function withFormlyFieldSwitch(): ConfigOption;
+declare function withFormlyFieldUsernameWithDomain(): ConfigOption;
+declare function withFormlyFieldCustomSwitch(): ConfigOption;
+declare function withFormlyFieldFormlySplit(): ConfigOption;
+declare function withFormlyFieldButtonSelection(): ConfigOption;
+declare function withFormlyFieldAvatarLabelButton(): ConfigOption;
+declare function withFormlyFieldFormlyButton(): ConfigOption;
+declare function withFormlyFieldLabelType(): ConfigOption;
+declare function withFormlyFieldClickableLabelType(): ConfigOption;
+declare function withFormlyFieldOptionTag(): ConfigOption;
+declare function withFormlyFieldRepeat(): ConfigOption;
+declare function withFormlyFieldTabs(): ConfigOption;
+declare function withFormlyFieldTag(): ConfigOption;
+declare function withFormlyFieldColorTag(): ConfigOption;
+declare function withFormlyFieldIconPicker(): ConfigOption;
+declare function withFormlyFieldColorPicker(): ConfigOption;
+declare function withFormlyFieldTemplate(): ConfigOption;
+declare function withFormlyFieldButton(): ConfigOption;
+declare function withFormlyFieldAvatarImage(): ConfigOption;
+declare function withFormlyPrimeIconPicker(): ConfigOption;
+declare function withFormlyWrappers(): ConfigOption;
+
+export { FormlyUiAllModule, globalGenericSelectorExtension, provideAllFormlyFields, withFormlyFieldAttachment, withFormlyFieldAvatarImage, withFormlyFieldAvatarLabelButton, withFormlyFieldButton, withFormlyFieldButtonSelection, withFormlyFieldClickableLabelType, withFormlyFieldColorPicker, withFormlyFieldColorTag, withFormlyFieldCustomSwitch, withFormlyFieldFormlyButton, withFormlyFieldFormlySplit, withFormlyFieldGenericSelector, withFormlyFieldIconPicker, withFormlyFieldInputWithIcon, withFormlyFieldLabelType, withFormlyFieldOptionTag, withFormlyFieldRepeat, withFormlyFieldRichTextEditor, withFormlyFieldSwitch, withFormlyFieldTabs, withFormlyFieldTag, withFormlyFieldTemplate, withFormlyFieldUsernameWithDomain, withFormlyPrimeIconPicker, withFormlyQueryBuilder, withFormlyWrappers };

package/types/es.framework-ng.ui.core-formly-ui.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from '@angular/core';
+import { Provider } from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class FormlyUiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyUiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyUiModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyUiModule>;
+}
+
+declare function provideFormly(): Provider[];
+
+export { FormlyUiModule, provideFormly };

package/types/es.framework-ng.ui.core-formly-username-with-domain.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import { FieldType, FieldTypeConfig } from '@ngx-formly/core';
+
+declare class FormlyUsernameWithDomainModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyUsernameWithDomainModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyUsernameWithDomainModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyUsernameWithDomainModule>;
+}
+
+declare class UsernameWithDomainComponent extends FieldType<FieldTypeConfig> {
+    readonly domain = "@ELITESOFTSYS.COM";
+    ngOnInit(): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsernameWithDomainComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UsernameWithDomainComponent, "lib-formly-username-with-domain", never, {}, {}, never, never, true, never>;
+}
+
+export { FormlyUsernameWithDomainModule, UsernameWithDomainComponent };

package/types/es.framework-ng.ui.core-generic-assets.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class GenericAssetsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericAssetsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GenericAssetsModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GenericAssetsModule>;
+}
+
+export { GenericAssetsModule };