import * as _angular_core from '@angular/core'; import { TemplateRef, AfterViewInit, OnDestroy, ElementRef, OnInit, SimpleChanges, OnChanges, Signal, Type, ViewContainerRef, AfterViewChecked, RendererFactory2, InjectionToken, Provider, EnvironmentProviders } from '@angular/core'; import { ValidatorFn, FormControl, FormGroup } from '@angular/forms'; import { DataBaseModelInterface } from '@solcre-org/core'; import { NgSelectComponent } from '@ng-select/ng-select'; import * as rxjs from 'rxjs'; import { Observable, Subject, BehaviorSubject } from 'rxjs'; import { SafeHtml } from '@angular/platform-browser'; import { Overlay } from '@angular/cdk/overlay'; import * as _solcre_org_core_ui from '@solcre-org/core-ui'; import { CanActivateFn } from '@angular/router'; import { HttpInterceptorFn, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpClient } from '@angular/common/http'; import { TranslateLoader, TranslateService } from '@ngx-translate/core'; import { TranslateHttpLoader } from '@ngx-translate/http-loader'; declare class CoreHostDirective { coreuiElement: string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class FieldErrorsComponent { errors: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface ActiveFilterItem { key: string; label: string; value: any; displayValue?: string; removable?: boolean; } interface ActiveFiltersConfig { showActiveFilters?: boolean; activeFiltersTitle?: string; clearFiltersLabel?: string; showClearButton?: boolean; customClass?: string; maxVisibleFilters?: number; formatters?: { [key: string]: (value: any) => string; }; } declare class ActiveFiltersComponent { private translateService; activeFilters: _angular_core.InputSignal; config: _angular_core.InputSignal; onFilterRemove: _angular_core.OutputEmitterRef; onClearAll: _angular_core.OutputEmitterRef; visibleFilters: _angular_core.Signal; hasFilters: _angular_core.Signal; showClearButton: _angular_core.Signal; activeFiltersTitle: _angular_core.Signal; clearFiltersLabel: _angular_core.Signal; containerClass: _angular_core.Signal; removeFilter(filter: ActiveFilterItem): void; clearAllFilters(): void; getDisplayValue(filter: ActiveFilterItem): string; isFilterRemovable(filter: ActiveFilterItem): boolean; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare enum TimeInterval { MINUTES_15 = "15_MINUTES", MINUTES_30 = "30_MINUTES", HOURLY = "HOURLY" } declare enum FieldType { TEXT = "text", TEXTAREA = "textarea", NUMBER = "number", CHECKBOX = "checkbox", SELECT = "select", DATE = "date", DATETIME = "datetime", TIME = "time", PASSWORD = "password", SWITCH = "switch", SERVER_SELECT = "server-select", FILE = "file", PHONE = "phone", DOCUMENT = "document" } declare enum NumberFieldType { DEFAULT = "default", DECIMAL = "decimal", INTEGER = "integer" } declare enum ModalMode { VIEW = "view", EDIT = "edit", CREATE = "create", FILTER = "filter" } interface MultiEntryFieldConfig { allowMultipleEntries?: boolean; maxEntries?: number; minEntries?: number; outputFormat?: MultiEntryOutputFormat; customSeparator?: string; labels?: { add?: string; remove?: string; }; format?: (entries: any[], formData: any) => any; } declare enum MultiEntryOutputFormat { ARRAY = "array", COMMA_SEPARATED = "comma_separated", CUSTOM_SEPARATOR = "custom_separator", INDIVIDUAL = "individual", CUSTOM_FORMAT = "custom_format" } interface MultiEntryFieldValue { entries: any[]; outputFormat: MultiEntryOutputFormat; separator?: string; } interface ModalFieldConfig { key: keyof T; keyToPayload?: string; label: string; placeholder?: string; type: FieldType.TEXT | FieldType.NUMBER | FieldType.CHECKBOX | FieldType.SELECT | FieldType.TEXTAREA | FieldType.DATE | FieldType.DATETIME | FieldType.TIME | FieldType.PASSWORD | FieldType.SWITCH | FieldType.SERVER_SELECT | FieldType.FILE | FieldType.PHONE | FieldType.DOCUMENT; options?: { value: any; label: string; }[]; dynamicOptions?: (row: T) => { value: any; label: string; }[]; readonly: boolean | ((formValue: any) => boolean); disabled?: boolean | ((formValue: any) => boolean) | ((row: T) => boolean); defaultValue?: any | ((row: T) => any); dynamicValue?: (formValue: any) => any; timeInterval?: TimeInterval; duration?: number; multiple?: boolean; linkedFieldKey?: keyof T; validators?: ValidatorFn[] | ((formValue: any) => ValidatorFn[]); errorMessages?: { [key: string]: string; }; visible?: boolean | (() => boolean) | ((formValue: any) => boolean) | ((row: T) => boolean); includeInPayload?: boolean; hasError?: boolean; blocked?: boolean; inline?: boolean; prefixIcon?: string; format?: (value: any, data: T) => string; customViewTemplate?: ((value: any, data: T) => string) | TemplateRef; multiEntryConfig?: MultiEntryFieldConfig; modes?: Partial any); readonly?: boolean | ((formValue: any) => boolean); disabled?: boolean | ((formValue: any) => boolean) | ((row: T) => boolean); options?: { value: any; label: string; }[]; validators?: ValidatorFn[] | ((formValue: any) => ValidatorFn[]); dynamicValue?: (formValue: any) => any; errorMessages?: { [key: string]: string; }; visible?: boolean | (() => boolean) | ((formValue: any) => boolean) | ((row: T) => boolean); includeInPayload?: boolean; multiple?: boolean; hasError?: boolean; errorMessage?: string; format?: (value: any, row: any) => string; customViewTemplate?: ((value: any, row: any) => string) | TemplateRef; }>>; } declare abstract class BaseFieldComponent { field: _angular_core.InputSignal>; value: _angular_core.InputSignal; mode: _angular_core.InputSignal; errors: _angular_core.InputSignal; rowData: _angular_core.InputSignal; formValue: _angular_core.InputSignal; valueChange: _angular_core.OutputEmitterRef; onBlurEvent: _angular_core.OutputEmitterRef; onEnterEvent: _angular_core.OutputEmitterRef; protected formControl: _angular_core.WritableSignal>; private lastEmittedValue; private isEnterPressed; isReadonly: _angular_core.Signal; protected evaluateReadonly(): boolean; protected evaluateDisabled(): boolean; hasError: _angular_core.Signal; hasRequiredValidators: _angular_core.Signal; ngOnInit(): void; constructor(); protected initializeFormControl(): void; protected getCurrentValidators(): ValidatorFn[]; protected getDynamicValue(): any; private normalizeValue; protected onBlur(event?: FocusEvent): void; private isRealBlur; private isWithinFieldArea; protected onEnter(event: KeyboardEvent): void; private resetEnterFlag; protected onValueChange(newValue: any): void; onBlurInput(event?: FocusEvent): void; onEnterInput(event: KeyboardEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-base-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; "formValue": { "alias": "formValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "onBlurEvent": "onBlurEvent"; "onEnterEvent": "onEnterEvent"; }, never, never, true, never>; } interface CheckboxOption { value: any; label: string; detail?: string; externalLink?: string; selected?: boolean; } interface CheckboxFieldConfig { externalLink?: string; detail?: string; options?: CheckboxOption[]; allowMultiple?: boolean; required?: boolean; separatedOptions?: boolean; } interface CheckboxModalFieldConfig extends ModalFieldConfig { checkboxConfig?: CheckboxFieldConfig; } declare class CheckboxFieldComponent extends BaseFieldComponent { isDisabled: _angular_core.Signal; externalLink: _angular_core.Signal; detail: _angular_core.Signal; options: _angular_core.Signal; allowMultiple: _angular_core.Signal; isRequired: _angular_core.Signal; hasRequiredIndicator: _angular_core.Signal; hasMultipleOptions: _angular_core.Signal; hasSeparatedOptions: _angular_core.Signal; constructor(); private shouldUpdateFromOptions; private updateValueFromSelected; protected initializeFormControl(): void; private getInitialValue; handleOptionChange(option: CheckboxOption, event: Event): void; onOptionChange(option: CheckboxOption, isChecked: boolean): void; isOptionSelected(option: CheckboxOption): boolean; cannotDeselect(option: CheckboxOption): boolean; onValueChange(newValue: any): void; onBlurInput(): void; onRadioChange(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-checkbox-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class DateFieldComponent extends BaseFieldComponent implements AfterViewInit, OnDestroy { private elementRef; private isPickerOpen; minDate: _angular_core.Signal; maxDate: _angular_core.Signal; constructor(elementRef: ElementRef); protected initializeFormControl(): void; ngAfterViewInit(): void; ngOnDestroy(): void; private initializeDateInput; private removeDateInputListeners; private showDatePicker; private updateHasValue; onBlurInput(): void; onCalendarClick(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-date-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class DatetimeFieldComponent implements OnInit { field: _angular_core.InputSignal>; value: _angular_core.InputSignal; mode: _angular_core.InputSignal; errors: _angular_core.InputSignal; rowData: _angular_core.InputSignal; formValue: _angular_core.InputSignal; valueChange: _angular_core.OutputEmitterRef; onBlurEvent: _angular_core.OutputEmitterRef; onEnterEvent: _angular_core.OutputEmitterRef; ModalMode: typeof ModalMode; TimeInterval: typeof TimeInterval; selectedDate: _angular_core.WritableSignal; selectedHour: _angular_core.WritableSignal; selectedMinute: _angular_core.WritableSignal; private hasHourValue; private hasMinuteValue; hours: number[]; isHourPlaceholderVisible: _angular_core.Signal; isMinutePlaceholderVisible: _angular_core.Signal; hoursOptions: _angular_core.Signal<{ value: number; label: string; }[]>; availableMinutes: _angular_core.Signal; minutesOptions: _angular_core.Signal<{ value: number; label: string; }[]>; hasRequiredValidators: _angular_core.Signal; private getCurrentValidators; formattedDate: _angular_core.Signal; isDisabled: _angular_core.Signal; hasError: _angular_core.Signal; private evaluateReadonly; constructor(); ngOnInit(): void; ngOnChanges(changes: SimpleChanges): void; private initializeValues; onDateChange(event: Event): void; onHourChange(value: number): void; onMinuteChange(value: number): void; private emitValue; private roundToNearestInterval; onBlur(): void; onEnter(event: KeyboardEvent): void; onCalendarClick(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-datetime-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; "formValue": { "alias": "formValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "onBlurEvent": "onBlurEvent"; "onEnterEvent": "onEnterEvent"; }, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } interface DocumentOption { value: string; label: string; } declare enum DocumentPayloadMode { OBJECT = "object", SEPARATE_KEYS = "separateKeys" } interface DocumentFieldConfig extends ModalFieldConfig { documentTypeOptions?: DocumentOption[]; documentTypePlaceholder?: string; documentNumberPlaceholder?: string; documentTypeChars?: number; documentNumberChars?: number; payloadMode?: DocumentPayloadMode; documentTypeKey?: string; documentNumberKey?: string; } interface DocumentFieldValue { documentType: string; documentNumber: string; } declare class DocumentFieldComponent extends BaseFieldComponent { protected documentTypeControl: FormControl; protected documentNumberControl: FormControl; private isUserEditing; defaultDocumentOptions: DocumentOption[]; fieldConfig: _angular_core.Signal>; documentTypeOptions: _angular_core.Signal; isDisabled: _angular_core.Signal; documentTypeChars: _angular_core.Signal; documentNumberChars: _angular_core.Signal; constructor(); private emitValue; onDocumentTypeChange(event: Event): void; onDocumentNumberChange(event: Event): void; onDocumentTypeFocus(): void; onDocumentNumberFocus(): void; onDocumentTypeBlur(): void; onDocumentNumberBlur(): void; getDocumentTypePlaceholder(): string; getDocumentNumberPlaceholder(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-document-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare enum FileType { COMPANY_INVENTORY = "company_inventory", COMPANY_LEGAL = "company_legals", COMPANY_AZF_PROCEDURE = "company_azf_procedure", COMPANY_TELEWORK = "company_remote_work", FILE_TEMPLATE = "file_template", COMPANY_EMPLOYEES_BULK = "company_employees_bulk" } interface PreviewFileUrl { id: string; url: string; } interface FileFieldConfig extends ModalFieldConfig { accept?: string; multiple?: boolean; maxFiles?: number; minFiles?: number; maxSize?: number; showPreview?: boolean; acceptString: string; previewUrls?: PreviewFileUrl[] | ((row: T) => PreviewFileUrl[]); onFileRemoved?: (data: { file: any; index: number; fileType: 'existing' | 'selected' | 'preview'; previewFile?: PreviewFileUrl; }) => void; onFilesAdded?: (data: { previewUrls: PreviewFileUrl[]; newFiles: File[]; }) => void; fileUploadConfig?: { fileType?: FileType; fileTypeResolver?: (data: T) => FileType; companyIdSource?: keyof T; staticCompanyId?: string; fileIdTarget?: keyof T; }; customActions?: { id: string; label: string; icon: string; action: (value: any) => void; }[]; } interface ServerFile { id: string; filename: string; size?: number; type?: string; s3_key?: string; created_at?: string; updated_at?: string; } declare class FileFieldComponent extends BaseFieldComponent implements AfterViewInit { private authService; selectedFiles: _angular_core.WritableSignal; existingFiles: _angular_core.WritableSignal; previewUrls: _angular_core.WritableSignal; newFilesPreviews: _angular_core.WritableSignal; previewBlobs: _angular_core.WritableSignal; previewFileIds: _angular_core.WritableSignal>; errorMessage: _angular_core.WritableSignal; errorParams: _angular_core.WritableSignal; displayErrorMessage: _angular_core.Signal<{ key: string; params: any; } | { key: string; params?: undefined; } | null>; fieldConfig: _angular_core.Signal>; isEditMode: _angular_core.Signal; ModalMode: typeof ModalMode; allFiles: _angular_core.Signal<(File | ServerFile)[]>; allPreviewUrls: _angular_core.Signal; private previewUrlsEffect; private valueChangeEffect; private getPreviewUrls; private createBlobsFromUrls; private extractFilenameFromUrl; ngOnInit(): void; ngAfterViewInit(): void; protected initializeFormControl(): void; private filesCountValidator; private initializeFiles; private regeneratePreviewsIfNeeded; isServerFile(value: any): value is ServerFile; private generatePreviews; onFileSelected(event: Event): void; private setLocalError; private clearLocalError; removeFile(index: number): void; private validateCurrentState; private emitCurrentValue; getFileIcon(file: File): string; formatFileSize(bytes: number): string; getCurrentDate(): string; getCurrentUser(): string; getPreviewIndex(file: any): number; getPreviewUrlForFile(file: any): string | null; getPreviewUrl(file: any): string | null; isPreviewFile(file: any): boolean; getOriginalUrl(file: any): string | null; onBlurInput(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-file-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare enum NumberFieldConfigType { DEFAULT = "default", WITH_ICON = "with-icon", OUTSIDE = "outside" } interface NumberFieldConfig { type?: NumberFieldConfigType; icon?: string; chars?: number; disableInput?: boolean; canUseInput?: boolean; } interface NumberModalFieldConfig extends ModalFieldConfig { numberConfig?: NumberFieldConfig; } declare class NumberFieldComponent extends BaseFieldComponent implements OnDestroy { private elementRef; readonly NumberFieldConfigType: typeof NumberFieldConfigType; private holdInterval; private holdTimeout; private currentHoldDirection; private holdSpeed; private minHoldSpeed; private accelerationRate; private isHolding; private wasHeld; fieldType: _angular_core.Signal; iconClass: _angular_core.Signal; getDisableInput(): boolean | null; getCanUseInput(): boolean; getCharsWidth(): string | null; isDisabled(): boolean; getMinValue(): number; getMaxValue(): number | null; isDecrementDisabled(): boolean; isIncrementDisabled(): boolean; constructor(elementRef: ElementRef); ngOnDestroy(): void; handleMouseDown(event: MouseEvent, direction: number): void; handleMouseUp(event: MouseEvent): void; handleTouchStart(event: TouchEvent, direction: number): void; handleTouchEnd(event: TouchEvent): void; onControlClick(change: number): void; private executeIncrement; private startHold; private stopHold; private restartInterval; onValueChange(newValue: any): void; onBlurInput(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-number-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class PasswordFieldComponent extends BaseFieldComponent { showPassword: _angular_core.WritableSignal; constructor(); inputType(): "text" | "password"; togglePasswordVisibility(): void; onBlurInput(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-password-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare enum AlertType { DEFAULT = "default", ERROR = "error", SUCCESS = "success", HIGHLIGHTED = "highlight", WAITING = "waiting" } declare enum NumberRange { MIN = "min", MAX = "max" } declare enum LayoutBreakpoint { MOBILE = "mobile", TABLET = "tablet", DESKTOP = "desktop" } declare enum SidebarVisibility { SHOW = "show", HIDE = "hide" } declare enum LayoutType { DEFAULT = "default" } declare enum SidebarHeight { DEFAULT = "default", FULL = "full" } declare enum SidebarPosition { LEFT = "left", RIGHT = "right" } declare enum SidebarWidth { DEFAULT = "default", WIDE = "wide" } declare enum SidebarMobileType { SELECT = "select", SCROLL = "scroll", MODAL = "modal" } declare enum HeaderElementType { GLOBAL_ACTIONS = "globalActions", CUSTOM_ACTIONS = "customActions", FILTER = "filter", CREATE = "create", CUSTOM_TEMPLATE = "customTemplate", INDIVIDUAL_ACTION = "individualAction" } declare enum CountryCode { AD = "AD", AE = "AE", AF = "AF", AG = "AG", AI = "AI", AL = "AL", AM = "AM", AO = "AO", AR = "AR", AS = "AS", AT = "AT", AU = "AU", AW = "AW", AX = "AX", AZ = "AZ", BA = "BA", BB = "BB", BD = "BD", BE = "BE", BF = "BF", BG = "BG", BH = "BH", BI = "BI", BJ = "BJ", BL = "BL", BM = "BM", BN = "BN", BO = "BO", BQ = "BQ", BR = "BR", BS = "BS", BT = "BT", BW = "BW", BY = "BY", BZ = "BZ", CA = "CA", CC = "CC", CD = "CD", CF = "CF", CG = "CG", CH = "CH", CI = "CI", CK = "CK", CL = "CL", CM = "CM", CN = "CN", CO = "CO", CR = "CR", CU = "CU", CV = "CV", CW = "CW", CX = "CX", CY = "CY", CZ = "CZ", DE = "DE", DJ = "DJ", DK = "DK", DM = "DM", DO = "DO", DZ = "DZ", EC = "EC", EE = "EE", EG = "EG", EH = "EH", ER = "ER", ES = "ES", ET = "ET", FI = "FI", FJ = "FJ", FK = "FK", FM = "FM", FO = "FO", FR = "FR", GA = "GA", GB = "GB", GD = "GD", GE = "GE", GG = "GG", GH = "GH", GI = "GI", GL = "GL", GM = "GM", GN = "GN", GQ = "GQ", GR = "GR", GT = "GT", GU = "GU", GW = "GW", GY = "GY", HK = "HK", HN = "HN", HR = "HR", HT = "HT", HU = "HU", ID = "ID", IE = "IE", IL = "IL", IM = "IM", IN = "IN", IO = "IO", IQ = "IQ", IR = "IR", IS = "IS", IT = "IT", JE = "JE", JM = "JM", JO = "JO", JP = "JP", KE = "KE", KG = "KG", KH = "KH", KI = "KI", KM = "KM", KN = "KN", KP = "KP", KR = "KR", KW = "KW", KY = "KY", KZ = "KZ", LA = "LA", LB = "LB", LC = "LC", LI = "LI", LK = "LK", LR = "LR", LS = "LS", LT = "LT", LU = "LU", LV = "LV", LY = "LY", MA = "MA", MC = "MC", MD = "MD", ME = "ME", MG = "MG", MH = "MH", MK = "MK", ML = "ML", MM = "MM", MN = "MN", MO = "MO", MP = "MP", MQ = "MQ", MR = "MR", MS = "MS", MT = "MT", MU = "MU", MV = "MV", MW = "MW", MX = "MX", MY = "MY", MZ = "MZ", NA = "NA", NE = "NE", NF = "NF", NG = "NG", NI = "NI", NL = "NL", NO = "NO", NP = "NP", NR = "NR", NU = "NU", NZ = "NZ", OM = "OM", PA = "PA", PE = "PE", PF = "PF", PG = "PG", PH = "PH", PK = "PK", PL = "PL", PN = "PN", PS = "PS", PT = "PT", PW = "PW", PY = "PY", QA = "QA", RO = "RO", RS = "RS", RU = "RU", RW = "RW", SA = "SA", SB = "SB", SC = "SC", SD = "SD", SE = "SE", SG = "SG", SI = "SI", SK = "SK", SL = "SL", SM = "SM", SN = "SN", SO = "SO", SR = "SR", SS = "SS", ST = "ST", SV = "SV", SX = "SX", SY = "SY", SZ = "SZ", TC = "TC", TD = "TD", TG = "TG", TH = "TH", TJ = "TJ", TK = "TK", TL = "TL", TM = "TM", TN = "TN", TO = "TO", TR = "TR", TT = "TT", TV = "TV", TW = "TW", TZ = "TZ", UA = "UA", UG = "UG", UN = "UN", US = "US", UY = "UY", UZ = "UZ", VA = "VA", VC = "VC", VE = "VE", VG = "VG", VI = "VI", VN = "VN", VU = "VU", WS = "WS", XK = "XK", XX = "XX", YE = "YE", ZA = "ZA", ZM = "ZM", ZW = "ZW" } declare const ALL_COUNTRY_CODES: CountryCode[]; declare function isValidCountryCode(code: string): code is CountryCode; declare function getCountryCodeStrings(): string[]; declare enum DayState { DEFAULT = "default", ACTIVE = "active", CURRENT = "current", DISABLED = "disabled", SELECTED = "selected" } declare enum DayType { PREVIOUS_MONTH = "previous", CURRENT_MONTH = "current", NEXT_MONTH = "next" } declare enum CalendarEventType { BLOCKED = "blocked", UNAVAILABLE = "unavailable", EVENT = "event", PENDING = "pending", USER_EVENT = "user-event", CONFIRMED = "confirmed", CANCELLED = "cancelled", COMPLETED = "completed", REJECTED = "rejected", EXPIRED = "expired" } declare enum WeekDay { MONDAY = 0, TUESDAY = 1, WEDNESDAY = 2, THURSDAY = 3, FRIDAY = 4, SATURDAY = 5, SUNDAY = 6 } interface CountryOption { code: CountryCode; phone: string; name: string; flag?: string; } interface PhoneFieldConfig { availableCountries?: CountryOption[] | 'all' | 'common' | 'latin-america' | 'south-america' | 'custom'; customCountriesList?: CountryCode[]; defaultCountry?: CountryCode; showFlags?: boolean; showCountryCode?: boolean; showPhoneCode?: boolean; phonePlaceholder?: string; validatePhoneFormat?: boolean; separator?: string; countrySelectWidth?: number; flagsBasePath?: string; payloadFormat?: 'fullNumber' | 'phoneNumber' | 'phoneCode' | 'countryCode' | 'object'; } interface PhoneModalFieldConfig extends ModalFieldConfig { phoneConfig?: PhoneFieldConfig; } declare class PhoneFieldComponent extends BaseFieldComponent { countryControl: FormControl; phoneControl: FormControl; phoneConfig: _angular_core.Signal<{ availableCountries: CountryOption[] | "all" | "common" | "latin-america" | "south-america" | "custom"; customCountriesList?: CountryCode[]; defaultCountry: string; showFlags: boolean; showCountryCode: boolean; showPhoneCode: boolean; phonePlaceholder: string; validatePhoneFormat: boolean; separator: string; countrySelectWidth: number; flagsBasePath: string; payloadFormat: "fullNumber" | "phoneNumber" | "phoneCode" | "countryCode" | "object"; }>; availableCountries: _angular_core.Signal; selectedCountry: _angular_core.WritableSignal; private dropdownOpen; private isUpdatingValue; isDisabled: _angular_core.Signal; private readonly hostElement; constructor(); private setInitialValue; private parseStringValue; private updatePhoneValue; private syncCountryFromControl; getCountryLabel(country: CountryOption): string; getPhonePlaceholder(): string; getFlagUrl(country: CountryOption): string; onBlurInput(): void; private validatePhoneFormat; static getLatinAmericaConfig(): Partial>; static getCommonCountriesConfig(): Partial>; isDropdownOpen(): boolean; onDocumentClick(event: MouseEvent): void; toggleDropdown(): void; selectCountry(country: CountryOption, event?: Event): void; onFlagError(event: Event): void; getSelectedCountryDisplay(): string; onAreaCodeClick(event: Event): void; onAreaCodeKeydown(event: KeyboardEvent): void; onPhoneKeyPress(event: KeyboardEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-phone-field", never, {}, {}, never, never, true, never>; } interface SelectFieldConfig extends ModalFieldConfig { options?: { value: any; label: string; data?: any; }[]; dynamicOptions?: (row: T) => { value: any; label: string; data?: any; }[]; dynamicValue?: (formValue: any) => any; onSelectionChange?: (selectedItem: { value: any; label: string; data?: any; } | null, currentFormValue: any) => any; bindValue?: string; bindLabel?: string; searchable?: boolean; clearable?: boolean; placeholder?: string; noResultsText?: string; } declare class SelectFieldComponent extends BaseFieldComponent { ngSelect: NgSelectComponent; field: _angular_core.InputSignal>; selectionChange: _angular_core.OutputEmitterRef<{ selectedItem: any; newFormValue: any; }>; private isInitialized; private hasValue; private userHasInteracted; private lastDynamicValue; computedValue: _angular_core.Signal; isPlaceholderVisible: _angular_core.Signal; isSearchable: _angular_core.Signal; isDisabled: _angular_core.Signal; constructor(); ngOnInit(): void; compareWith: (item: any, selected: any) => boolean; onValueChange(newValue: any): void; private findSelectedItem; isOptionSelected(optionValue: string): boolean; onBlurInput(): void; private scheduleDynamicValue; private shouldApplyDynamicValue; private hasMeaningfulValue; private areValuesEqual; private cloneValue; onSelectChange(value: any): void; onSelectClear(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-select-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } interface SearchResponse { data?: T[]; [key: string]: T[] | undefined; } declare class ServerSelectService { private apiService; search(endpoint: string, term: string, searchParam?: string, responseKey?: string, additionalParams?: { [key: string]: any; }): Observable; getInitialItems(endpoint: string, responseKey?: string): Observable; private processEndpoint; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } interface SelectServerSideConfig extends ModalFieldConfig { endpoint?: string | ((row: T | null) => string); bindValue?: string; bindLabel?: string; labelKeys?: string[]; labelFormatter?: (item: T | any) => string; labelTemplate?: string; labelSeparator?: string; searchParam?: string; responseKey?: string; dynamicOptions?: (row: T) => { value: any; label: string; data?: any; }[]; preloadedOptions?: any[]; minSearchLength?: number; additionalParams?: (formValue: any) => { [key: string]: any; }; dependsOn?: string; onSelectionChange?: (selectedItem: { value: any; label: string; data?: any; } | null, currentFormValue: any) => any; } interface SelectItem extends DataBaseModelInterface { [key: string]: any; } declare class ServerSelectFieldComponent extends BaseFieldComponent implements OnInit, OnDestroy, AfterViewInit { ngSelect: NgSelectComponent; field: _angular_core.InputSignal>; selectionChange: _angular_core.OutputEmitterRef<{ selectedItem: any; newFormValue: any; }>; private serverSelectService; private loaderService; private destroy$; private initialized; private isEvaluatingDynamicOptions; private lastRowDataHash; private hasValueSignal; constructor(); private itemsSignal; items: _angular_core.Signal; private isLoadingSignal; isLoading: _angular_core.Signal; private hasSearchedSignal; hasSearched: _angular_core.Signal; private lastSearchResultsSignal; lastSearchResults: _angular_core.Signal; searchInput$: Subject; private dynamicOptionsThrottle$; computedValue: _angular_core.Signal; isSearchable: _angular_core.Signal; isPlaceholderVisible: _angular_core.Signal; compareWith: (item: SelectItem | null, selected: any) => boolean; getDisplayLabel: (item: SelectItem) => string; private throttledEvaluateDynamicOptions; ngOnInit(): void; private initializeWithOptions; private getCurrentRowData; private initializeWithPreloadedOptions; private initializeWithExistingValues; private hasValue; private updateItemsWithValue; private setValidOptions; private updateItemsIfDifferent; private mergeWithSelectedItems; private getSelectedItemsOnly; ngAfterViewInit(): void; ngOnDestroy(): void; onValueChange(newValue: any): void; private findSelectedItem; isOptionSelected(optionValue: string): boolean; onBlurInput(): void; onClear(): void; onSelectChange(value: any): void; onSelectClear(): void; onSearch(event: { term: string; items: any[]; }): void; onFocus(): void; onOpen(): void; onBeforeOpen(): boolean; onFieldClick(): void; onClose(): void; private evaluateDynamicOptions; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-server-select-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class SwitchFieldComponent extends BaseFieldComponent { isDisabled: _angular_core.Signal; constructor(); labelOff: _angular_core.Signal; labelOn: _angular_core.Signal; private getCurrentValue; protected initializeFormControl(): void; onValueChange(newValue: any): void; onBlurInput(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-switch-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class TextAreaFieldComponent extends BaseFieldComponent { constructor(); isDisabled(): boolean; onBlurInput(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-text-area-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class TextFieldComponent extends BaseFieldComponent { constructor(); isDisabled(): boolean; getInputType(): string; getCharsWidth(): string | null; onBlurInput(event?: FocusEvent): void; handleEnterKey(event: Event): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-text-field", never, {}, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } interface TimeFieldValue { startTime: string | null; endTime?: string | null; } interface TimeOption { value: string; label: string; used?: boolean; } interface TimeFieldConfig { options: TimeOption[]; timeInterval?: TimeInterval; includeEndTime?: boolean; startTimeLabel?: string; endTimeLabel?: string; enforceEndTimeAfterStart?: boolean; defaultStartTime?: string; defaultEndTime?: string; } declare class TimeFieldComponent { field: _angular_core.InputSignal & { config?: TimeFieldConfig; }>; value: _angular_core.InputSignal; mode: _angular_core.InputSignal; errors: _angular_core.InputSignal; rowData: _angular_core.InputSignal; formValue: _angular_core.InputSignal; valueChange: _angular_core.OutputEmitterRef; onBlurEvent: _angular_core.OutputEmitterRef; onEnterEvent: _angular_core.OutputEmitterRef; ModalMode: typeof ModalMode; selectedStartTime: _angular_core.WritableSignal; selectedEndTime: _angular_core.WritableSignal; private hasStartValue; private hasEndValue; config: _angular_core.Signal; isStartPlaceholderVisible: _angular_core.Signal; isEndPlaceholderVisible: _angular_core.Signal; availableOptions: _angular_core.Signal; startTimeOptions: _angular_core.Signal<{ disabled: boolean; value: string; label: string; used?: boolean; }[]>; endTimeOptions: _angular_core.Signal<{ disabled: boolean; value: string; label: string; used?: boolean; }[]>; includeEndTime: _angular_core.Signal; startTimeLabel: _angular_core.Signal; endTimeLabel: _angular_core.Signal; isDisabled: _angular_core.Signal; hasError: _angular_core.Signal; hasRequiredValidators: _angular_core.Signal; startTimeErrors: _angular_core.Signal; endTimeErrors: _angular_core.Signal; hasStartTimeError: _angular_core.Signal; hasEndTimeError: _angular_core.Signal; hasStartTimeRequiredValidator: _angular_core.Signal; hasEndTimeRequiredValidator: _angular_core.Signal; private getCurrentValidators; private evaluateReadonly; constructor(); private initializeFromValue; private generateTimeOptions; onStartTimeChange(value: string | null): void; onEndTimeChange(value: string | null): void; private emitValue; private validateIndividualFields; onStartTimeBlur(): void; onEndTimeBlur(): void; private isTimeBeforeOrEqual; private isEmptyValue; private applyDefaultValues; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-time-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; "formValue": { "alias": "formValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "onBlurEvent": "onBlurEvent"; "onEnterEvent": "onEnterEvent"; }, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } interface ExtendedModalFieldConfig extends ModalFieldConfig { multiEntryConfig?: MultiEntryFieldConfig; } declare class MultiEntryFieldComponent implements OnInit { field: _angular_core.InputSignal>; value: _angular_core.InputSignal; mode: _angular_core.InputSignal; errors: _angular_core.InputSignal; rowData: _angular_core.InputSignal; formValue: _angular_core.InputSignal; valueChange: _angular_core.OutputEmitterRef; onBlurEvent: _angular_core.OutputEmitterRef; onEnterEvent: _angular_core.OutputEmitterRef; hasErrors: _angular_core.OutputEmitterRef; ModalMode: typeof ModalMode; entries: _angular_core.WritableSignal; fieldValues: _angular_core.WritableSignal; entryErrors: _angular_core.WritableSignal>; private isSyncingFromInput; private lastInputSignature; private lastEmittedSignature; config: _angular_core.Signal; allowMultiple: _angular_core.Signal; maxEntries: _angular_core.Signal; minEntries: _angular_core.Signal; outputFormat: _angular_core.Signal; addLabel: _angular_core.Signal; removeLabel: _angular_core.Signal; canAddMore: _angular_core.Signal; canRemove: _angular_core.Signal; isDisabled: _angular_core.Signal; hasRequiredValidators: _angular_core.Signal; private getCurrentValidators; constructor(); ngOnInit(): void; private initializeEntries; private generateEntryId; addEntry(): void; removeEntry(index: number): void; onFieldValueChange(value: any, index: number): void; private validateEntry; getEntryErrors(index: number): string[]; hasAnyErrors(): boolean; onFieldBlur(fieldKey: keyof T): void; onFieldEnter(fieldKey: keyof T): void; private emitFormattedValue; createFieldConfigForEntry(index: number): ModalFieldConfig; shouldShowActions(index: number): boolean; shouldShowAddButton(index: number): boolean; shouldShowRemoveButton(index: number): boolean; private serializeValue; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-multi-entry-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; "formValue": { "alias": "formValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "onBlurEvent": "onBlurEvent"; "onEnterEvent": "onEnterEvent"; "hasErrors": "hasErrors"; }, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class SmartFieldComponent implements OnInit { field: _angular_core.InputSignal | ExtendedModalFieldConfig>; value: _angular_core.InputSignal; mode: _angular_core.InputSignal; errors: _angular_core.InputSignal; rowData: _angular_core.InputSignal; formValue: _angular_core.InputSignal; valueChange: _angular_core.OutputEmitterRef; onBlurEvent: _angular_core.OutputEmitterRef; onEnterEvent: _angular_core.OutputEmitterRef; selectionChange: _angular_core.OutputEmitterRef<{ selectedItem: any; newFormValue: any; }>; shouldUseMultiEntry: _angular_core.Signal; ngOnInit(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-smart-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; "formValue": { "alias": "formValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "onBlurEvent": "onBlurEvent"; "onEnterEvent": "onEnterEvent"; "selectionChange": "selectionChange"; }, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class LoaderService { private loadingRequests; private activeLoaders; isLoading$: rxjs.Observable; isLoading: _angular_core.Signal; showLoader(requestId?: string): void; hideLoader(requestId?: string): void; clear(): void; getState(): { activeLoaders: number; requests: Record; }; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class LoaderComponent { private loaderService; imageUrl: _angular_core.InputSignal; requestId: _angular_core.InputSignal; isLoading: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface DataListItem { key: string; label: string; value?: any; formattedValue?: string; visible?: boolean | ((data: any) => boolean); format?: (value: any, data?: any) => string; customTemplate?: TemplateRef | ((value: any, data?: any) => string); cssClasses?: { item?: string; key?: string; value?: string; }; } declare class DataListComponent { items: _angular_core.InputSignal; fields: _angular_core.InputSignal[]>; data: _angular_core.InputSignal; customTemplate: _angular_core.InputSignal | null>; showEmptyMessage: _angular_core.InputSignal; emptyMessage: _angular_core.InputSignal; cssClasses: _angular_core.InputSignal; normalizedItems: _angular_core.Signal; visibleItems: _angular_core.Signal; hasData: _angular_core.Signal; hasVisibleItems: _angular_core.Signal; shouldShowContent: _angular_core.Signal; shouldShowEmptyMessage: _angular_core.Signal; private convertFieldsToItems; getItemValue(item: DataListItem): any; getFormattedValue(item: DataListItem): string; private getDefaultFormattedValue; private formatSingleValue; getItemTemplateContext(item: DataListItem): any; getItemTemplateRef(item: DataListItem): TemplateRef | null; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-data-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "customTemplate": { "alias": "customTemplate"; "required": false; "isSignal": true; }; "showEmptyMessage": { "alias": "showEmptyMessage"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "cssClasses": { "alias": "cssClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } declare class DataListItemComponent { key: _angular_core.InputSignal; label: _angular_core.InputSignal; value: _angular_core.InputSignal; formattedValue: _angular_core.InputSignal; customTemplate: _angular_core.InputSignal | null>; templateContext: _angular_core.InputSignal; itemCssClasses: _angular_core.InputSignal; keyCssClasses: _angular_core.InputSignal; valueCssClasses: _angular_core.InputSignal; customCssClasses: _angular_core.InputSignal<{ item?: string; key?: string; value?: string; }>; getItemClasses(): string; getKeyClasses(): string; getValueClasses(): string; hasCustomTemplate(): boolean; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare enum ButtonContext { DEFAULT = "default", ERROR = "error", SUCCESS = "success" } declare enum ButtonSize { SMALL = "small", MEDIUM = "medium", LARGE = "large" } declare enum ButtonType { PRIMARY = "c-btn", STROKE = "c-btn--stroke", SECONDARY = "c-btn--secondary", ICON = "c-icon-btn", ICON_FILL = "c-icon-btn--fill", LINK = "c-link", LINK_UNDERLINED = "c-link--underlined", LINK_SECONDARY = "c-link--secondary", LINK_SECONDARY_UNDERLINED = "c-link--secondary c-link--underlined" } interface ButtonConfig { type: ButtonType; context?: ButtonContext; size?: ButtonSize; text?: string; icon?: string; iconPosition?: 'left' | 'right'; disabled?: boolean; loading?: boolean; customClass?: string; globalCustomClass?: string; ariaLabel?: string; tooltip?: string; href?: string; target?: '_blank' | '_self' | '_parent' | '_top'; routerLink?: string | any[]; queryParams?: { [key: string]: any; }; fragment?: string; requiredPermission?: { resource?: string; resources?: string[]; action?: string; actions?: string[]; custom_action?: string; }; id?: string; showTextOnIcon?: boolean; tooltipConfig?: { hasTooltip?: boolean; text: string; position: 'top' | 'bottom' | 'left' | 'right'; }; } interface ButtonActionEvent { originalEvent: Event; buttonConfig: any; data?: any; } declare class GenericButtonComponent { ButtonType: typeof ButtonType; ButtonContext: typeof ButtonContext; ButtonSize: typeof ButtonSize; private permissionService; config: _angular_core.InputSignal; data: _angular_core.InputSignal; buttonClick: _angular_core.OutputEmitterRef; get hostClasses(): string; isDisabled: _angular_core.Signal; private checkRequiredPermission; buttonClasses: _angular_core.Signal; isLink: _angular_core.Signal; isIconOnly: _angular_core.Signal; shouldShowText: _angular_core.Signal; hasIcon: _angular_core.Signal; hasText: _angular_core.Signal; iconPositionLeft: _angular_core.Signal; iconPositionRight: _angular_core.Signal; onClick(event: Event): void; getAriaLabel(): string; getTitle(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface ModalTabConfig { tabId: string; tabLabel: string; fields: ModalFieldConfig[]; hasError?: boolean; visible?: boolean; icon?: string; } declare enum StepStatus { PENDING = "pending", ACTIVE = "active", COMPLETE = "complete" } declare enum StepType { NUMBER = "number", TEXT = "text", ICON = "icon" } interface StepItemConfig { id: string; title: string; status: StepStatus; type: StepType; content?: string | number; icon?: string; disabled?: boolean; clickable?: boolean; customClass?: string; tooltip?: string; data?: any; } interface ModalStepConfig extends StepItemConfig { fields: ModalFieldConfig[]; hasError?: boolean; visible?: boolean; customTemplate?: TemplateRef | null; } interface ModalButtonConfig { text: string; class?: string; action: (data: T | null) => void; disabled?: boolean; } interface GenericTab { id: string; label?: string; translationKey?: string; disabled?: boolean; active?: boolean; data?: any; customClass?: string; hasErrors?: boolean; } interface GenericTabConfig { tabs: GenericTab[]; containerClass?: string; listClass?: string; itemClass?: string; linkClass?: string; activeClass?: string; disabledClass?: string; allowCustomTemplate?: boolean; } declare enum StepSize { SMALL = "small", MEDIUM = "medium", LARGE = "large" } interface StepsConfig { steps: StepItemConfig[]; activeStepId?: string; size?: StepSize; showConnectors?: boolean; clickable?: boolean; customClass?: string; colors?: { pending?: string; active?: string; complete?: string; connector?: string; }; layout?: 'horizontal' | 'vertical'; showLabels?: boolean; showNumbers?: boolean; onStepClick?: (step: StepItemConfig) => void; } declare class GenericModalComponent { private elementRef; private formBuilder; private domSanitizer; private confirmationDialogService; private alertService; ModalMode: typeof ModalMode; FieldType: typeof FieldType; isClosing: _angular_core.WritableSignal; isOpen: _angular_core.InputSignal; mode: _angular_core.InputSignal; data: _angular_core.InputSignal; fields: _angular_core.InputSignal[]>; tabs: _angular_core.InputSignal[]>; steps: _angular_core.InputSignal[]>; title: _angular_core.InputSignal; isMultiple: _angular_core.InputSignal; customTemplate: _angular_core.InputSignal | null>; customViewTemplate: _angular_core.InputSignal | null>; finalStepTemplate: _angular_core.InputSignal | null>; buttonConfig: _angular_core.InputSignal[]>; modelFactory: _angular_core.InputSignal<((data: Partial) => T) | null>; errors: _angular_core.InputSignal; validators: _angular_core.InputSignal<((data: T) => string[])[]>; customHasChanges: _angular_core.InputSignal; stepValidationEnabled: _angular_core.InputSignal; allowFreeNavigation: _angular_core.InputSignal; autoMarkCompleted: _angular_core.InputSignal; save: _angular_core.OutputEmitterRef; close: _angular_core.OutputEmitterRef; modalData: _angular_core.OutputEmitterRef; editedData: _angular_core.WritableSignal; internalErrors: _angular_core.WritableSignal; fieldErrors: _angular_core.WritableSignal<{ [key: string]: string[]; }>; isInitialized: _angular_core.WritableSignal; form: _angular_core.WritableSignal>; activeTabId: _angular_core.WritableSignal; activeStepId: _angular_core.WritableSignal; originalData: _angular_core.WritableSignal; hasUnsavedChanges: _angular_core.WritableSignal; hasTabs: _angular_core.Signal; hasSteps: _angular_core.Signal; allFields: _angular_core.Signal[]>; activeTabFields: _angular_core.Signal[]>; activeStepFields: _angular_core.Signal[]>; currentFields: _angular_core.Signal[]>; visibleFieldsForView: _angular_core.Signal[]>; dataListItems: _angular_core.Signal<{ key: string; label: string; value: T[keyof T]; formattedValue: string; visible: boolean; customTemplate: TemplateRef | ((value: any, data: T) => string) | undefined; }[]>; visibleTabs: _angular_core.Signal[]>; visibleSteps: _angular_core.Signal[]>; currentStepIndex: _angular_core.Signal; isLastStep: _angular_core.Signal; currentStep: _angular_core.Signal | null>; showSaveButton: _angular_core.Signal; currentStepErrors: _angular_core.Signal; isCurrentStepValid: _angular_core.Signal; canGoToNextStep: _angular_core.Signal; completedStepIds: _angular_core.Signal>; canNavigateFreely: _angular_core.Signal; stepsConfig: _angular_core.Signal; hasErrors: _angular_core.Signal; genericTabsConfig: _angular_core.Signal; closeButtonConfig: _angular_core.Signal; defaultCancelButtonConfig: _angular_core.Signal; defaultSaveButtonConfig: _angular_core.Signal; prevStepButtonConfig: _angular_core.Signal; nextStepButtonConfig: _angular_core.Signal; hasTabErrorsFunction: (tabId: string) => boolean; getCustomButtonConfig(button: ModalButtonConfig): ButtonConfig; private getButtonTypeFromClass; onCustomButtonClick(button: ModalButtonConfig): void; constructor(); private initializeData; private initializeActiveTabAndStep; private validateField; private mapDynamicValidatorErrors; onFieldValueChange(fieldKey: keyof T, newValue: any): void; onSelectionChange(event: { selectedItem: any; newFormValue: any; }): void; updateField(fieldKey: keyof T, value: any): void; validateAllFields(): void; validateCurrentStepFields(): void; getFieldErrors(fieldKey: keyof T): string[]; getStepErrors(step: ModalStepConfig): string[]; getFormattedValue(field: ModalFieldConfig, value: any): string; hasCustomViewTemplate(field: ModalFieldConfig): boolean; isTemplateRef(template: any): template is TemplateRef; getCustomTemplate(field: ModalFieldConfig): TemplateRef | null; getSafeHtml(field: ModalFieldConfig, value: any): SafeHtml; onSave(): void; setCustomHasChanges(hasChanges: boolean): void; private filterPayloadData; private convertEmptyStringsToNull; onClose(): void; private forceClose; getFieldConfig(field: ModalFieldConfig): ModalFieldConfig; private evaluateVisibility; private evaluateReadonly; onBlurEvent(fieldKey: keyof T): void; onTabChange(tabId: string): void; onGenericTabChange(tab: GenericTab): void; onStepChange(stepId: string): void; goToPreviousStep(): void; goToNextStep(): void; hasTabErrors(tabId: string): boolean; hasStepErrors: (stepId: string) => boolean; private detectFormChanges; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "core-generic-modal", never, { "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; "steps": { "alias": "steps"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "isMultiple": { "alias": "isMultiple"; "required": false; "isSignal": true; }; "customTemplate": { "alias": "customTemplate"; "required": false; "isSignal": true; }; "customViewTemplate": { "alias": "customViewTemplate"; "required": false; "isSignal": true; }; "finalStepTemplate": { "alias": "finalStepTemplate"; "required": false; "isSignal": true; }; "buttonConfig": { "alias": "buttonConfig"; "required": false; "isSignal": true; }; "modelFactory": { "alias": "modelFactory"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "customHasChanges": { "alias": "customHasChanges"; "required": false; "isSignal": true; }; "stepValidationEnabled": { "alias": "stepValidationEnabled"; "required": false; "isSignal": true; }; "allowFreeNavigation": { "alias": "allowFreeNavigation"; "required": false; "isSignal": true; }; "autoMarkCompleted": { "alias": "autoMarkCompleted"; "required": false; "isSignal": true; }; }, { "save": "save"; "close": "close"; "modalData": "modalData"; }, never, never, true, [{ directive: typeof CoreHostDirective; inputs: {}; outputs: {}; }]>; } interface PaginationEvent { page: number; size: number; tableId: string; } declare class PaginationService { private paginationState; private paginationChange; paginationChange$: rxjs.Observable; initialize(tableId: string, totalItems: number, pageSizeOptions?: number[]): void; getCurrentPage(tableId: string): _angular_core.WritableSignal; getPageSize(tableId: string): _angular_core.WritableSignal; getTotalItems(tableId: string): _angular_core.WritableSignal; getTotalPages(tableId: string): _angular_core.WritableSignal; getPageSizeOptions(tableId: string): number[]; setCurrentPage(tableId: string, page: number): void; setPageSize(tableId: string, size: number): void; setTotalItems(tableId: string, total: number): void; setTotalPages(tableId: string, pages: number): void; private getState; private emitPaginationChange; destroy(tableId: string): void; getCurrentPaginationParams(tableId: string): Record; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } interface FilterParams { [key: string]: any; } interface PaginatedResponse { items: T[]; total: number; page: number; pages: number; size: number; } declare class TableDataService { private static readonly DEFAULT_PAGE_SIZE; private modelApiService; private apiService; private loaderService; private displayedDataSubject; private currentEndpoint; private currentModelFactory; private currentFilterParams; private currentPaginationParams; private currentCustomParams; private isPaginationEnabled; private currentCustomArrayKey; private isLoading; data$: Observable>; displayedData$: Observable; setData(newData: T[]): void; getData(): T[]; getDisplayedData(): T[]; setEndpoint(endpoint: string, modelFactory: (json: any) => T, loaderId?: string, enablePagination?: boolean, customArrayKey?: string, customParams?: Record