import * as i1 from '@angular/router';
import { ActivatedRoute, Route, LoadChildrenCallback, Routes, DefaultExport, Router, NavigationExtras, QueryParamsHandling, RouterModule, CanActivateChildFn } from '@angular/router';
import * as _angular_forms from '@angular/forms';
import { FormControl, AbstractControl, FormGroup, AsyncValidatorFn, ValidatorFn, AbstractControlOptions, FormArray, FormControlOptions, UntypedFormArray, FormsModule, ReactiveFormsModule, ControlValueAccessor } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Observable, ReplaySubject, OperatorFunction, Subscription, BehaviorSubject, Subject } from 'rxjs';
import * as _angular_core from '@angular/core';
import { TemplateRef, Type, EventEmitter, Provider, EnvironmentProviders, ResourceRef, ChangeDetectorRef, OnInit, SimpleChanges, ElementRef, DestroyRef, OnDestroy, PipeTransform, InputSignal, Signal, ViewContainerRef, WritableSignal, Renderer2, AfterViewInit, OnChanges, ApplicationRef, InjectionToken, ErrorHandler } from '@angular/core';
import * as i1$1 from '@angular/common';
import { KeyValue, Location, CurrencyPipe, TitleCasePipe, DatePipe, DecimalPipe, CommonModule } from '@angular/common';
import * as i37 from '@angular/material/menu';
import { MenuPositionX, MatMenuModule } from '@angular/material/menu';
import * as ets_fe_ng_sdk from 'ets-fe-ng-sdk';
import { MatAutocomplete, MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import { MatSelect } from '@angular/material/select';
import * as _angular_material_dialog from '@angular/material/dialog';
import { MatDialog, MatDialogConfig, MatDialogRef, MatDialogModule } from '@angular/material/dialog';
import * as _serene_dev_toast_notifications from '@serene-dev/toast-notifications';
import { ToastNotificationsService } from '@serene-dev/toast-notifications';
import { MatSnackBar } from '@angular/material/snack-bar';
import { Title, DomSanitizer } from '@angular/platform-browser';
import jfd from 'js-file-download';
import { BreakpointObserver } from '@angular/cdk/layout';
import * as Sentry from '@sentry/angular';
import { ContentChange, QuillEditorComponent, QuillModules } from 'ngx-quill';
import { MatCalendar } from '@angular/material/datepicker';
import { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HttpInterceptorFn } from '@angular/common/http';
import { MatOption } from '@angular/material/core';
import { IconDefinition } from '@fortawesome/free-solid-svg-icons';
import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i14 from '@angular/material/tooltip';
import { MatTooltipModule } from '@angular/material/tooltip';
import * as _angular_material_paginator from '@angular/material/paginator';
import { MatPaginator, PageEvent } from '@angular/material/paginator';
import * as intl_tel_input_i18n_types from 'intl-tel-input/i18n/types';
import { TelInputOptions } from '@serene-dev/ng-tel-input';
import { Iti } from 'intl-tel-input';
import { SelectionModel, SelectionChange } from '@angular/cdk/collections';
import { MatSort, Sort as Sort$1 } from '@angular/material/sort';
import { MatTable, MatTableDataSource } from '@angular/material/table';
import { NestedTreeControl } from '@angular/cdk/tree';
import { MatDrawerMode, MatDrawer } from '@angular/material/sidenav';
import { MatTreeNestedDataSource } from '@angular/material/tree';
import { Idle } from '@ng-idle/core';
import PerfectScrollbar from 'perfect-scrollbar';
import { ETSTranslationService } from '@evolutics/translation';
import { Store, Action, ActionCreator } from '@ngrx/store';
import { Actions } from '@ngrx/effects';
import { SwUpdate } from '@angular/service-worker';
import * as i25 from '@fortawesome/angular-fontawesome';
import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
import * as i34 from '@angular/material/button';
import { MatButtonModule } from '@angular/material/button';
import * as i36 from '@angular/material/expansion';
import { MatExpansionModule } from '@angular/material/expansion';
import * as i4 from '@angular/cdk/clipboard';
import * as i4$1 from '@angular/material/progress-bar';

declare global {
    interface String {
        /**
         * Removes the specified character from the string
         * @param character Character to remove (defaults to '/')
         * @returns String with the character removed
         */
        stripChar(character?: string): string;
        /**
         * Removes the specified character from the end of the string if present
         * @param character Character to remove from the end (defaults to '/')
         * @returns String with the character removed from the end if it was present
         */
        lastStripChar(character?: string): string;
        /**
         * Remove null from string content.
         * @returns String with null values removed
         */
        removeNull(): string;
        /**
         * Removes all instances of a character from a string
         * @param character Character to remove (defaults to '/')
         * @param replacement String to replace with (defaults to '')
         * @returns String with all instances of the character removed or replaced
         */
        unChar(character?: string, replacement?: string): string;
        /**
         * Converts Pascal case to Sentence case
         * @example 'smallBook'.toSentenceCase() = 'Small Book'
         * @returns String in sentence case
         */
        toSentenceCase(): string;
        /**
         * Replaces all occurrences of a substring
         * @param character Character to replace (defaults to '/')
         * @param replacement String to replace with (defaults to '')
         * @returns The string after replacement
         */
        replaceAllSubStr(character?: string, replacement?: string): string;
        /**
         * Adds a character at the beginning of a string until it reaches the expected length
         * @param character Character to add before string
         * @param expectedLength Expected length of the string after addition of the character
         * @returns String with added preceding characters
         */
        addPrecedingChar(character: string, expectedLength: number): string;
    }
    interface Array<T> {
        merge(): T;
        /**
         * @param index The index to select from the end.
         * @defaultValue 0
         * @example ['a','b','c'].reverseIndex(1) returns 'b'
         * @example ['a','b','c','d','e'].reverseIndex(2) returns 'c'
         */
        reverseIndex(index?: number): T;
        lastItem(): T;
        /**
         * Shuffles the content of an array
         */
        shuffle(): T[];
        /**
         * Sort by the length of the field specified in ascending order
         * @param field Field name to compare with
         * @param reverse Should it be in a descending order
         */
        sortByFieldLength(field: keyof T, reverse?: boolean): T[];
        /**
         *
         * @param field Field name to compare with
         * @param isString Is the data type of the field a string
         * @param reverse Should it be in a descending order
         */
        sort2(field: keyof T, isString?: boolean, reverse?: boolean): T[];
        /**
         * Detects the data type of the field to sort by
         * @param field Field name to compare with
         * @param reverse Should it be in a descending order
         */
        sort3(field: keyof T, reverse?: boolean): T[];
        /**
         * Remove items from an array that don't have values in any of its fields
         * @param expectedFields Fields to check for emptiness, the function will remove the rows that don't have any value in all the fields specified while keeping the rows that have at least one value
         * @param config Config
         * @returns The items removed
         */
        removeEmptyItems(expectedFields?: (keyof T)[], config?: {
            /**
             * Specify whether to check the value in boolean fields.
             * @defaultValue `false`
             */
            ignoreBooleanFields?: boolean;
            /**
             * Specify whether to check for emptiness in the 'expectedFields' or check for emptiness in the other fields excluding the fields specified
             * @defaultValue `included`
             */
            fieldsType?: 'included' | 'excluded';
        }): T[];
        /**
         * Converts an array to a key value pair.
         * @param keyField The field to be used as the key
         * @returns An index object containing the keyField as the index key and each item of the array as value assigned to each index
         */
        toMap(keyField: keyof T): {
            [x: string]: T;
        };
        /**
         * Converts an array to a key value pair.
         * @param keyMap Function to set the key of the map
         */
        toMap(keyMap: (row: T) => string | number): {
            [x: string]: T;
        };
        /**
         * Converts an array to a key value pair.
         * @param keyField The field to be used as the key
         * @param valueMap Function to set the values of each key in the map
         * @returns An index object containing the keyField as the index key and each item of the array as value assigned to each index
         */
        toMap<NT>(keyField: keyof T, valueMap: (item: T) => NT): {
            [x: string]: NT;
        };
        /**
         * Groups an array by unique entries in a field.
         * @param arr Array to be grouped
         * @param keyField The field to be used as the key
         */
        groupBy(keyField: keyof T, keyMap?: (value: T) => string): {
            [x: string]: T[];
        };
        /**
         * Turns an array to a map.
         */
        toBooleanMap(): {
            [x: string]: boolean;
        };
    }
    interface Function {
        clone: any;
    }
}
declare module '@angular/forms' {
    interface AbstractControl {
        formattedValue?: any;
        labelValue?: string;
        getFormattedValue: () => any;
    }
    interface FormControl {
        formattedValue?: string;
        labelValue?: string;
        getFormattedValue: () => string;
    }
    interface FormGroup {
        formattedValue?: {
            [x: string]: string[] | {
                [x: string]: string;
            }[];
        };
        getFormattedValue: () => {
            [x: string]: string[] | {
                [x: string]: string;
            }[];
        };
    }
    interface FormArray {
        formattedValue?: string[] | {
            [x: string]: string;
        }[];
        getFormattedValue: () => string[] | {
            [x: string]: string;
        }[];
    }
}
declare module '@angular/router' {
    interface Route {
        customData?: {
            miID?: string;
            title?: string;
            pageComponent?: {
                centerHeader?: boolean;
                hideHeader?: boolean;
            };
        };
    }
}

declare namespace prototypes_d {
  export {
  };
}

/**
 * A utility class for managing loading states in an application.
 * Tracks multiple concurrent loading operations and provides methods to start, stop,
 * and check the overall loading state.
 */
declare class PageLoader {
    /**
     * Internal array to track active loading operations.
     * Each element represents a single loading operation.
     * @private
     */
    private _pageLoaders;
    constructor();
    /**
     * Indicates whether any loading operations are currently active.
     * @returns {boolean} True if at least one loading operation is active, false otherwise.
     */
    get isLoading(): boolean;
    /**
     * Starts one or more loading operations.
     * @param {number} value - The number of loading operations to start. Defaults to 1.
     * @returns {number} The total number of active loading operations after starting.
     */
    startPl: (value?: number) => number;
    /**
     * Resets and restarts the loading state with a single loading operation.
     * Clears all existing loading operations and starts a new one.
     */
    restartPl: () => void;
    /**
     * Stops one or more loading operations.
     * @param {number} value - The number of loading operations to stop. Defaults to 1.
     * @returns {number} The total number of active loading operations after stopping.
     */
    stopPl: (value?: number) => number;
    /**
     * Stops all active loading operations at once.
     * Completely clears the loading state.
     */
    stopAllPls: () => void;
}

/**
 * Represents a basic route item with path generation capabilities.
 * Handles route path construction with optional parameters.
 */
declare class RouteItem {
    /** The full route path including parameters */
    _: string;
    /** The base route path without parameters */
    __: string;
    /** The public route path including parent path */
    pub: string;
    /**
     * Creates a new RouteItem instance.
     * @param base - The base route segment
     * @param parentPub - The parent public path (defaults to empty string)
     * @param params - Optional route parameters to append
     */
    constructor(base: string, parentPub?: string, ...params: string[]);
}
/**
 * Extended route class that provides common application routes and utility methods.
 * Creates a standard set of routes for CRUD operations and navigation.
 */
declare class AppRouteBase extends RouteItem {
    /**
     * Creates a new AppRouteBase with standard child routes.
     * @param base - The base route segment
     * @param parentPub - The parent public path (defaults to empty string)
     * @param params - Optional route parameters to append
     */
    constructor(base: string, parentPub?: string, ...params: string[]);
    /** Route for listing all items */
    all: RouteItem;
    /** Route for cloning an item by ID */
    clone: RouteItem;
    /** Route for creating new items with specialized sub-routes */
    create: CreateRoute;
    /** Route for editing an item by ID */
    edit: RouteItem;
    /** Route for finding/searching items */
    find: FindRoute;
    /** Route for the index/listing page */
    index: RouteItem;
    /** Route for overview page */
    overview: RouteItem;
    /** Route for showing a single item by ID */
    show: RouteItem;
    /** Route for starting a process */
    start: RouteItem;
    /**
     * Combines a route with a parent ID.
     * @param route - The base route
     * @param prtID - The parent ID to append
     * @returns The combined route string or null if route is falsy
     */
    routeIdPipe(route: string, prtID: string): string;
    /**
     * Creates a route with ID and formatted title.
     * @param route - The base route
     * @param id - The item ID
     * @param title - Optional title to format and append
     * @returns The formatted route string
     */
    routeIdTitlePipe(route: string, id: string, title?: string): string;
    /**
     * Creates a route with parent ID, item ID, and formatted title.
     * @param route - The base route
     * @param parentID - The parent item ID
     * @param id - The item ID
     * @param title - Optional title to format and append
     * @returns The formatted route string
     */
    routePIdIdTitlePipe(route: string, parentID: string, id: string, title?: string): string;
    /**
     * Creates a route with parent ID, sub-item ID, item ID, and formatted title.
     * @param route - The base route
     * @param parentID - The parent item ID
     * @param subID - The sub-item ID
     * @param id - The item ID
     * @param title - Optional title to format and append
     * @returns The formatted route string
     */
    routePidSidIdTitlePipe(route: string, parentID: string, subID: string, id: string, title?: string): string;
    /**
     * Formats a title for use in a URL.
     * Trims, removes special characters, converts to lowercase, and replaces spaces with hyphens.
     * @param title - The title to format
     * @returns The URL-friendly formatted title or empty string if no title provided
     */
    routeNamer(title?: string): string;
}
/**
 * Specialized route for creation operations with different entity types.
 */
declare class CreateRoute extends RouteItem {
    /** Route for corporate entity creation */
    corporate: RouteItem;
    /** Route for group entity creation */
    group: RouteItem;
    /** Route for individual entity creation */
    individual: RouteItem;
    /** Route for provider entity creation with sub-routes */
    provider: CreateProviderRoute;
}
/**
 * Specialized route for provider creation operations.
 */
declare class CreateProviderRoute extends RouteItem {
    /** Index route for provider creation */
    index: RouteItem;
}
/**
 * Specialized route for find/search operations.
 */
declare class FindRoute extends RouteItem {
    /** Route for search results list */
    searchList: RouteItem;
}

/**
 * Defines the visual style of a button
 */
type BtnType = 'clear' | 'close' | 'danger-outline' | 'danger' | 'dark-outline' | 'dark' | 'outline-nm' | 'outline' | 'primary' | 'secondary' | 'success';
/**
 * Predefined button groups for common actions
 */
type BtnGroup = 'add' | 'clone' | 'close' | 'create' | 'save' | 'delete' | 'download' | 'edit' | 'link' | 'search' | 'show' | 'submit' | 'upload';
/**
 * Available icon types for buttons
 */
type IconType = 'access' | 'add' | 'adjust' | 'arrowh' | 'bank' | 'calendar' | 'cancel' | 'cash' | 'checked' | 'pause' | 'checklist' | 'clone' | 'close' | 'stop' | 'cogs' | 'delete' | 'download' | 'dropdown' | 'edit' | 'error' | 'export' | 'file' | 'filter' | 'generate' | 'guard' | 'history' | 'home' | 'import' | 'info' | 'link' | 'lock' | 'next' | 'pen' | 'percent' | 'play' | 'post' | 'previous' | 'receipt' | 'recycle' | 'refresh' | 'renew' | 'save' | 'search' | 'shake' | 'show' | 'snooze' | 'spoon' | 'table' | 'tag' | 'truck' | 'unlock' | 'upload' | 'users' | 'view';
/**
 * Interface for button configuration
 *
 * @interface IBtn
 * @extends IKVP
 */
interface IBtn {
    /** Unique identifier for the pair */
    readonly key?: any;
    /** Value associated with the key */
    value?: string | boolean | number;
    /** CSS class(es) to apply to the pair */
    cls?: string;
    /** Function to execute when button is clicked */
    action?: (arg?: any) => void;
    /** Predefined button group */
    group?: BtnGroup;
    /** Help text for the button */
    help?: string;
    /** Route to navigate to when button is clicked */
    route?: string;
    /** Icon to display on the button */
    icon?: IconType;
    /** Whether the button should be displayed as an icon only */
    iconBtn?: boolean;
    /** Whether the button should be displayed in mini size */
    mini?: boolean;
    /** Whether to show a help icon */
    showHelpIcon?: boolean;
    /** Text label for the button */
    label?: string;
    /** Child buttons for dropdown/menu buttons */
    children?: IBtn[];
    /** Visual style of the button */
    type?: BtnType;
    /** Additional data to associate with the button */
    extra?: any;
}
/**
 * Button class implementation
 *
 * @class Btn
 * @implements {IBtn}
 * @template TData Type of data passed to the action function
 */
declare class Btn<TData = any> implements IBtn {
    /** Additional CSS classes */
    cls?: string;
    /** Predefined button group */
    group?: BtnGroup;
    /** Help text for the button */
    help?: string;
    /** Custom icon class */
    customIcon?: string;
    /** Predefined icon type */
    icon?: IconType;
    /** Whether the button should be displayed in mini size */
    mini?: boolean;
    /** Whether the button should be displayed as an icon only */
    iconBtn?: boolean;
    /** Function to execute when button is clicked */
    readonly action?: (data?: TData, ...args: any[]) => void;
    /** Unique identifier for the button */
    readonly key?: string;
    /** Whether to show a help icon */
    showHelpIcon?: boolean;
    /** Text label for the button */
    label?: string;
    /** Route to navigate to when button is clicked */
    route?: string;
    /** Visual style of the button */
    type?: BtnType;
    /** Additional data to associate with the button */
    extra?: any;
    /** Whether the button is in loading state */
    loading?: boolean;
    /** Child buttons for dropdown/menu buttons */
    children?: Btn<TData>[];
    /** Whether the button is disabled */
    disabled?: boolean;
    /**
     * @deprecated use the literal object approach
     *
     * Instead of
     * ```const btn = new Btn(...)```
     * do
     * ```const btn: IBtn = {...}```
     *
     * @param key Unique identifier for the button
     * @param action Function to execute when button is clicked
     * @param type Visual style of the button
     * @param icon Icon to display on the button
     * @param cls Additional CSS classes
     * @param help Help text for the button
     * @param showHelpIcon Whether to show a help icon
     * @param loading Whether the button is in loading state
     * @param disabled Whether the button is disabled
     */
    constructor(key: string, action?: (data?: TData, ...args: any[]) => any, type?: BtnType, icon?: IconType, cls?: string, help?: string, showHelpIcon?: boolean, loading?: boolean, disabled?: boolean);
}
/**
 * Large button implementation with simplified properties
 *
 * @class BtnLg
 * @implements {IBtn}
 */
declare class BtnLg implements IBtn {
    /** Unique identifier for the button */
    readonly key: string;
    /** Value associated with the button */
    value: string | boolean | number;
    /** Function to execute when button is clicked */
    readonly action?: () => void;
    /** Additional CSS classes */
    cls?: string;
    /** Additional data to associate with the button */
    extra?: any;
    /**
     * Creates an instance of BtnLg
     *
     * @param key Unique identifier for the button
     * @param value Value associated with the button
     * @param action Function to execute when button is clicked
     * @param cls Additional CSS classes
     * @param extra Additional data to associate with the button
     */
    constructor(key: string, value?: string | boolean | number, action?: any, cls?: string, extra?: any);
}

/**
 * Base interface for ETS input components
 */
interface IETSInputBase {
    /** Optional name identifier for the input */
    name?: string;
    /** Display label for the input */
    label: string;
    /** Current value of the input */
    value?: any;
    /** Placeholder text to display when input is empty */
    placeholder?: string;
    /** CSS class(es) to apply to the input */
    cls?: string;
    /** Whether the input is required */
    required?: boolean;
    /** Type of input to render */
    type?: InputType;
}
/**
 * Interface for form control inputs that extends the base input interface
 */
interface IETSFCInput extends IETSInputBase {
    /** Name identifier for the input (required for form controls) */
    name: string;
    /** Text or icon to display before the input */
    prefix?: string;
    /** Text or icon to display after the input */
    suffix?: string;
    /** Angular form control associated with this input */
    formControl: AbstractControl;
    /** Parent form group containing this input */
    form: FormGroup;
    /** Validation messages to display for this input */
    vms?: IValidationMessage[];
}
/**
 * Supported input types for ETS components
 */
type InputType = 'autocomplete' | 'button' | 'checkbox' | 'checkedbox' | 'color' | 'date' | 'datetime-local' | 'dhm' | 'email' | 'file' | 'fileButton' | 'number' | 'password' | 'progress' | 'percentage' | 'richtext' | 'radio' | 'select' | 'tel' | 'template' | 'text' | 'textarea' | 'time' | 'viewer';
/**
 * Implementation of form control input interface
 *
 * @class FCInput
 * @implements {IETSFCInput}
 * @description A class that implements the IETSFCInput interface for form control inputs
 */
declare class FCInput implements IETSFCInput {
    /** Name identifier for the input (required for form controls) */
    name: string;
    /** Display label for the input */
    label: string;
    /** Placeholder text to display when input is empty */
    placeholder?: string;
    /** CSS class(es) to apply to the input */
    cls?: string;
    /** Text or icon to display before the input */
    prefix?: string;
    /** Text or icon to display after the input */
    suffix?: string;
    /** Whether the input is required */
    required?: boolean;
    /** Type of input to render */
    type?: InputType;
    /** Angular form control associated with this input */
    formControl: AbstractControl;
    /** Validation messages to display for this input */
    vms?: IValidationMessage[];
    /** Parent form group containing this input */
    form: FormGroup;
    /**
     * Creates an instance of FCInput.
     *
     * @param {string} label - Display label for the input
     * @param {string} [name] - Name identifier for the input (generated randomly if not provided)
     * @param {AbstractControl} [formControl] - Angular form control associated with this input
     * @param {InputType} [type] - Type of input to render (defaults to 'text')
     * @param {boolean} [required] - Whether the input is required (defaults to false)
     * @param {string} [placeholder] - Placeholder text to display when input is empty
     * @param {IValidationMessage[]} [vms] - Validation messages to display for this input
     * @param {string} [prefix] - Text or icon to display before the input
     * @param {string} [suffix] - Text or icon to display after the input
     */
    constructor(label: string, name?: string, formControl?: AbstractControl, type?: InputType, required?: boolean, placeholder?: string, vms?: IValidationMessage[], prefix?: string, suffix?: string);
}
/**
 * Component-based ETS input implementation
 *
 * @class CETSInput
 * @implements {IETSInputBase}
 * @description A class that implements the IETSInputBase interface for component-based inputs
 */
declare class CETSInput implements IETSInputBase {
    /** Optional name identifier for the input */
    name: string;
    /** Display label for the input */
    label: string;
    /** Placeholder text to display when input is empty */
    placeholder?: string;
    /** CSS class(es) to apply to the input */
    cls?: string;
    /** Whether the input is required */
    required?: boolean;
    /** Type of input to render */
    type?: InputType;
    /** Current value of the input */
    value: string;
    /** Whether the input is hidden */
    hide: boolean;
    /** Whether the input is disabled */
    disabled: boolean;
    /** Whether the input is read-only */
    readonly: boolean;
    /** Unique identifier for the input element */
    id: string;
    /** Whether the input has validation errors */
    hasError: boolean;
    /**
     * Checks if the input value is empty
     *
     * @readonly
     * @type {boolean}
     * @returns {boolean} True if value is null or undefined
     */
    get isEmpty(): boolean;
    /** X-coordinate position (used for positioning) */
    x: number;
    /** Y-coordinate position (used for positioning) */
    y: number;
    /**
     * Creates an instance of CETSInput.
     *
     * @param {string} label - Display label for the input
     * @param {string} [name] - Optional name identifier for the input
     * @param {any} [value] - Current value of the input
     * @param {InputType} [type] - Type of input to render (defaults to 'text')
     * @param {boolean} [required] - Whether the input is required (defaults to false)
     * @param {string} [placeholder] - Placeholder text to display when input is empty
     * @param {IValidationMessage[]} [vms] - Validation messages (not used in this implementation)
     * @param {string} [prefix] - Text or icon to display before the input (not used in this implementation)
     * @param {string} [suffix] - Text or icon to display after the input (not used in this implementation)
     */
    constructor(label: string, name?: string, value?: any, type?: InputType, required?: boolean, placeholder?: string, vms?: IValidationMessage[], prefix?: string, suffix?: string);
}
/**
 * Interface for key-value pairs
 */
interface IKVP {
    /** Unique identifier for the pair */
    readonly key?: any;
    /** Value associated with the key */
    value?: string | boolean | number;
    /** CSS class(es) to apply to the pair */
    cls?: string;
}
/**
 * Basic implementation of key-value pair
 *
 * @class ETSKVP
 * @implements {IKVP}
 * @description A simple key-value pair implementation with optional CSS class
 */
declare class ETSKVP implements IKVP {
    /** Unique identifier for the pair */
    readonly key: string;
    /** Value associated with the key */
    value?: string | boolean | number;
    /** CSS class(es) to apply to the pair */
    cls?: string;
    /**
     * Creates an instance of ETSKVP.
     *
     * @param {string} key - Unique identifier for the pair
     * @param {string | boolean | number} [value] - Value associated with the key
     * @param {string} [cls] - CSS class(es) to apply to the pair
     */
    constructor(key: string, value?: string | boolean | number, cls?: string);
}
/**
 * Extended key-value pair with additional functionality
 *
 * @class ETSFKVP
 * @extends {ETSKVP}
 * @description An enhanced key-value pair with additional properties for UI display,
 * formatting, navigation, and interaction
 */
declare class ETSFKVP extends ETSKVP {
    inputType?: InputType;
    /** Display label for the pair */
    label: string;
    /** Whether the value can be edited by the user */
    editable?: boolean;
    /** Whether the value is currently being edited */
    editing?: boolean;
    /** Route to navigate to when the value is clicked */
    route?: string;
    /** Function to dynamically generate a route based on the item */
    routeFunc?: (item: any) => Promise<string> | Observable<string>;
    /** Tooltip or hint text for the key/label */
    hint?: string;
    /** Tooltip or hint text for the value */
    valueHint?: string;
    /** Function to execute when the value is clicked */
    action?: any;
    /** Whether the value represents a phone number (for formatting) */
    isPhone?: boolean;
    /** Whether the value represents an email address (for formatting) */
    isEmail?: boolean;
    /** Function to format the display value */
    formatter?: (val: any) => string | Promise<string> | Observable<string>;
    /**
     * Creates an instance of ETSFKVP.
     *
     * @param {string} key - Unique identifier for the pair
     * @param {string} label - Display label for the pair
     * @param {boolean} [editable] - Whether the value can be edited by the user
     * @param {string | boolean | number} [value] - Value associated with the key
     * @param {InputType} [inputType] - Type of input to use when editing the value
     * @param {string} [hint] - Tooltip or hint text for the key/label
     * @param {any} [action] - Function to execute when the value is clicked
     * @param {(val: any) => string | Promise<string>} [formatter] - Function to format the display value
     * @param {string} [cls] - CSS class(es) to apply to the pair
     * @param {string} [route] - Route to navigate to when the value is clicked
     * @param {string} [valueHint] - Tooltip or hint text for the value
     */
    constructor(key: string, label: string, editable?: boolean, value?: string | boolean | number, inputType?: InputType, hint?: string, action?: any, formatter?: (val: any) => string | Promise<string>, cls?: string, route?: string, valueHint?: string);
}
/**
 * Interface for label components that extends key-value pairs
 */
interface ILbl extends IKVP {
    /** Tooltip or hint text for the label */
    hint?: string;
}
/**
 * Implementation of label interface
 */
declare class Lbl implements ILbl {
    readonly key: string;
    value: string | boolean | number;
    hint?: string;
    cls?: string;
    constructor(key: string, value?: string | boolean | number, hint?: string, cls?: string);
}
/**
 * Interface for row options in tables
 * @template TRow Type of the row data
 */
interface IRowOption<TRow> {
    /** Text or title for the option */
    t: string;
    /** CSS class(es) to apply to the item */
    itemClass?: string;
    /** CSS class(es) to apply to the icon */
    iconClass?: string;
    /** Whether to ignore/hide this option */
    ignore?: boolean;
    /** Function to execute when option is selected */
    action?: (row: TRow) => void;
}
/**
 * Types of cells that can be displayed in tables
 */
type CellType = InputType | 'table' | 'btns' | 'editable' | 'input';
/**
 * Interface for table column configuration
 * @template TRow Type of the row data
 */
interface ITableCol<TRow = any> {
    /** Column header text */
    t: string;
    /** Custom template for rendering the cell */
    customTemplate?: TemplateRef<any>;
    /** Field name from row data to display in this column */
    f: KeyOfType<TRow, string | number | boolean>;
    /** Whether the column is disabled */
    disabled?: boolean;
    /** Function to format the cell value for display */
    formatter?: (val: any) => string | undefined | Promise<string | undefined> | Observable<string | undefined>;
    /** Array of property paths to access nested data */
    p?: string[];
    /** Formatter function that takes multiple parameters */
    formatterP?: (...val: any) => string;
    /** Function to generate hint/tooltip text for the cell */
    hintFormatter?: (val: TRow) => Promise<string | undefined> | Observable<string | undefined>;
    /** Function to generate a route for the cell */
    routeFormatter?: FormatterFuncType<string, TRow>;
    /** Function to generate query parameters for navigation */
    mqueryParams?: FormatterFuncType<{}, TRow>;
    /** Type of cell to render */
    type?: CellType;
    /** Whether this is an additional column that can be toggled by the user */
    additionalColumn?: boolean;
    /** Whether the column is currently active/visible */
    active?: boolean;
    /** Whether to show preview on hover */
    previewOnHover?: boolean;
    /** Configuration for hover behavior */
    onHoverHandler?: {
        /** Delay in milliseconds before showing hover content */
        delay?: number;
        /** Function to execute on hover */
        action: (row: TRow, event: MouseEvent) => any;
    };
    /** Whether to ignore/hide this column */
    ignore?: boolean;
    /** Function to execute when cell is clicked */
    action?: (row: TRow, cellField: keyof TRow, setLoading?: (value: boolean) => void, index?: number) => any;
}
/**
 * Implementation of table column interface with additional properties
 * @template TRow Type of the row data
 */
declare class TableCol<TRow = any> implements ITableCol<TRow> {
    /** Function to execute when cell is clicked */
    action?: (row: TRow, cellField: keyof TRow, setLoading?: (value: boolean) => void, index?: number) => any;
    /** Whether the column is currently active/visible */
    active?: boolean;
    /** Whether to show preview on hover */
    previewOnHover?: boolean;
    /** Configuration for hover behavior */
    onHoverHandler?: {
        /**In Milliseconds */ delay?: number;
        /** Function to execute on hover */
        action: (row: TRow, event: MouseEvent) => any;
    };
    /** Whether to ignore/hide this column */
    ignore?: boolean;
    /** Test number for internal use */
    testNumber?: number;
    /** Whether this is an additional column that can be toggled by the user */
    additionalColumn?: boolean;
    /** Button configuration for action columns */
    btn?: Btn<TRow>;
    /** Multiple buttons configuration for action columns */
    buttons?: Btn<TRow>[];
    /** Whether the column is checked/selected */
    checked?: boolean;
    /**
     * @deprecated Defaults to {@link stickyEnd}
     * Whether the column should be sticky
     */
    sticky?: boolean;
    /** Whether the column should stick to the start of the table */
    stickyStart?: boolean;
    /** Whether the column should stick to the end of the table */
    stickyEnd?: boolean;
    /** Field name from row data to display in this column */
    f: KeyOfType<TRow, string | number | boolean | undefined | null>;
    /** Function to format the cell value for display */
    formatter?: (val: any) => string | undefined | null | Promise<string | undefined | null> | Observable<string | undefined | null>;
    /** Function to format the cell value when expanded */
    expandedFormatter?: (val: any) => string | undefined | Promise<string | undefined> | Observable<string | undefined>;
    /** Function to generate hint/tooltip text for the cell */
    hintFormatter?: (val: TRow) => Promise<string | undefined> | Observable<string | undefined>;
    /** Formatter function that takes the entire row as input */
    formatterRow?: FormatterFuncType<string, TRow>;
    /** Expanded formatter function that takes the entire row as input */
    expandedFormatterRow?: FormatterFuncType<string, TRow>;
    /** Tooltip or hint text for the column */
    hint?: string;
    /** Icon type to display in the column */
    icon?: IconType;
    /** Function to generate query parameters for navigation */
    mqueryParams?: FormatterFuncType<{}, TRow>;
    /** Array of property paths to access nested data */
    p?: string[];
    /** Whether the column is disabled */
    disabled?: boolean;
    /** Function to generate a route for the cell */
    routeFormatter?: FormatterFuncType<string, TRow>;
    /** Configuration for nested table columns */
    subTable?: TableCol[];
    /** Column header text */
    t: string;
    /** Custom template for rendering the cell */
    customTemplate?: TemplateRef<any>;
    /** Type of cell to render */
    type?: CellType;
    /** Specify whether to show button to expand column */
    expandable?: boolean;
    /** Width to use when modal is opened */
    expandedWidth?: string;
    /** Whether to skip formatting for this column */
    noFormat?: boolean;
    constructor(t: string, f?: keyof TRow, formatter?: (val: any) => string | Promise<string>, formatterRow?: FormatterFuncType<string, TRow>, type?: CellType, checked?: boolean, routeFormatter?: FormatterFuncType<string, TRow>, mqueryParams?: FormatterFuncType<{}, TRow>, action?: (row: any, cellField: keyof TRow) => any);
}
/**
 * Type for formatter functions that operate on row data
 * @template R Return type of the formatter
 * @template T Type of the row data
 */
type FormatterFuncType<R = string, T = any> = (row: T, cellField?: keyof T) => R;
/**
 * Interface for items with code and title
 * @template Code Type of the code property
 */
interface ICodeTitle<Code = string> {
    /** Code or identifier */
    code: Code;
    /** Display title */
    title: string;
}
/**
 * Interface for items with code and description
 */
interface ICodeDescription {
    /** Code or identifier */
    code: string;
    /** Descriptive text */
    description: string;
}
/**
 * Interface for marketing events with code and description
 */
interface IMktDescription {
    /** Marketing event code */
    mktEventCode: string;
    /** Description of the marketing event */
    description: string;
}
/**
 * Interface for items with only a code property
 */
interface ICode {
    /** Code or identifier */
    code: string;
}
/**
 * Enum for menu location identifiers
 */
declare enum EMenuLocation {
    viewPage1 = "viewPage"
}
/**
 * Enum for days of the week
 */
declare enum Day {
    sunday = "Sunday",
    monday = "Monday",
    tuesday = "Tuesday",
    wednesday = "Wednesday",
    thursday = "Thursday",
    friday = "Friday",
    saturday = "Saturday"
}
/**
 * Enum for page types
 */
declare enum EPageType {
    clonePage = "clonePage",
    editPage = "editPage",
    showPage = "showPage",
    createPage = "createPage",
    indexPage = "indexPage"
}
/**
 * Interface for document metadata
 */
interface IDocMetadata {
    /** Box number */
    boxNo?: string;
    /** Branch identifier */
    branch?: string;
    /** Document category */
    category?: string;
    /** User who created the document */
    createdBy?: string;
    /** Policy code */
    policyCode?: string;
    /** Policy number */
    policyNo?: string;
    /** Policy number suffix */
    policyNoSuffix?: string;
    /** Reference category */
    refCat?: RefCat;
    /** Reference number */
    refNo?: string | number;
    /** Document sensitivity level */
    sensitivity?: string;
    /** Document subcategory */
    subCategory?: SubCategory;
    /** Document title */
    title: string;
}
/**
 * Type for reference categories used in document metadata
 * Represents different types of reference categories for documents in the system
 */
type RefCat = 'AGT' | 'APP' | 'ASS' | 'AUTH' | 'BAN' | 'BAT' | 'BRA' | 'CLA' | 'CLI' | 'COM' | 'COU' | 'COV' | 'DN' | 'DOC' | 'END' | 'ENR' | 'GRO' | 'NB' | 'PAY' | 'PNS' | 'PO' | 'POL' | 'PRO' | 'QUO' | 'RAT' | 'SN' | 'ST' | 'TAR' | 'TAS' | 'TRA' | 'TSC' | 'USR' | 'WF';
/**
 * Type for document subcategories
 * Represents different subcategories that can be assigned to documents
 */
type SubCategory = 'AGT' | 'AOC' | 'AP' | 'CN' | 'CSD' | 'ID' | 'LI' | 'LIC' | 'PP' | 'RIB' | 'SI';
/**
 * Interface for system configuration
 * @template SystemType Type of the system enum
 * @template TESystemBusLine Type of the system bus line enum
 */
interface ISystem<SystemType = ESystem, TESystemBusLine = ESystemBusLine> {
    /** Base route for the application */
    appRoute: AppRouteBase;
    /** System name identifier */
    name: SystemType;
    /** Business line the system belongs to */
    busline: TESystemBusLine;
    /** Color code for UI theming */
    colourCode: string;
    /** Root path for the system */
    rootPath: string;
}
/**
 * Enum for system identifiers
 * Represents different systems within the application
 */
declare enum ESystem {
}
/**
 * Enum for subsystem identifiers
 * Represents different subsystems within the main systems
 */
declare enum ESubSystem {
}
/**
 * Enum for system business line identifiers
 * Represents different business lines that systems can belong to
 */
declare enum ESystemBusLine {
}
/**
 * Enum for supported languages
 * Represents languages available for localization
 */
declare enum ELanguage {
    /** English */
    EN = "EN",
    /** French */
    FR = "FR"
}
/**
 * Enum for validation error types
 * Represents different types of validation errors that can occur in forms
 */
declare enum EValidationType {
    /** Custom validation error */
    custom = "custom",
    /** Generic invalid input error */
    invalid = "invalid",
    /** Input exceeds maximum length */
    maxlength = "maxlength",
    /** Input is shorter than minimum length */
    minlength = "minlength",
    /** Input doesn't match required pattern */
    pattern = "pattern",
    /** Required field is missing */
    required = "required",
    /** Value must be unique but isn't */
    unique = "unique",
    /** Value is not unique when it should be */
    notUnique = "notUnique",
    /** Referenced entity not found */
    notFound = "notFound",
    /** Value is already in use */
    used = "used",
    /** Invalid email format */
    email = "email",
    /** Validation is in progress */
    pending = "pending"
}
/**
 * Interface for validation messages
 * Defines the structure for validation error messages displayed to users
 */
interface IValidationMessage {
    /** Type of validation error */
    type: EValidationType;
    /** Message to display for this validation error */
    message: string;
}
/**
 * Sort direction type
 * Represents the direction of sorting (ascending or descending)
 */
type SortType = 'asc' | 'desc';
/**
 * Interface for sort information
 * Contains metadata about the sort state of paginated data
 */
interface Sort {
    /** Whether data is sorted (true if sorting is applied) */
    sorted: boolean;
    /** Whether data is unsorted (true if no sorting is applied) */
    unsorted: boolean;
    /** Whether sort configuration is empty (true if no sort parameters exist) */
    empty: boolean;
}
/**
 * Interface for paginated data
 * Represents a page of data with pagination metadata
 * @template T Type of the content items in the page
 */
interface IPage<T> {
    /** Array of items for the current page */
    content: T[];
    /** Current page number (0-based) */
    number: number;
    /** Page size (items per page) */
    size: number;
    /** Total number of items across all pages */
    totalElements: number;
    /** Total number of pages */
    totalPages: number;
    /** Whether this is the last page */
    last: boolean;
    /** Whether this is the first page */
    first: boolean;
    /** Sort information for the current page */
    sort: Sort;
    /** Number of elements in the current page */
    numberOfElements: number;
    /** Whether the page is empty (contains no items) */
    empty: boolean;
}
/**
 * Interface for query parameters when fetching paginated data
 * Defines standard pagination and sorting parameters
 * @template T Type of the row data being queried
 */
interface GetQuery<T> {
    /** Page number to retrieve (0-based) */
    pageNumber?: number;
    /** Number of items per page */
    pageSize?: number;
    /** Field to sort by (must be a key of T) */
    sortBy?: keyof T;
    /** Sort direction (ascending or descending) */
    sortDirection?: SortType | 'DESC' | 'ASC';
}
/**
 * Extended query interface that combines custom query parameters with standard pagination
 * Allows for domain-specific query parameters alongside standard pagination controls
 * @template TQuery Type of custom query parameters
 * @template TRow Type of the row data being queried
 */
type IGetQuery<TQuery = any, TRow = any> = Partial<TQuery> & GetQuery<TRow>;
/**
 * Interface for search response with pagination
 * Represents the response from a search operation with paginated results
 * @template T Type of the content items in the response
 */
interface ISearchResponse<T = any> {
    /** Paginated data containing the search results */
    page: IPage<T>;
    /** Total number of items matching the search criteria */
    listSize: number;
    /** Current page number (0-based) */
    pageNumber?: number;
    /** Number of items per page */
    pageSize?: number;
    /** Search criteria used for the query */
    searchCriteria: any;
    /** Original query parameters that were used for the search */
    query?: IGetQuery;
}
/**
 * Interface for search response with pagination and content directly accessible
 * Flattened version of search response where page content is directly accessible
 * @template T Type of the content items in the response
 */
interface ISearchResponse2<T = any> {
    /** Array of items for the current page */
    content: T[];
    /** Whether the page is empty (contains no items) */
    empty: boolean;
    /** Whether this is the first page */
    first: boolean;
    /** Whether this is the last page */
    last: boolean;
    /** Current page number (0-based) */
    number: number;
    /** Number of elements in the current page */
    numberOfElements: number;
    /** Page size (items per page) */
    size: number;
    /** Total number of items across all pages */
    totalElements: number;
    /** Total number of pages */
    totalPages: number;
    /** Original query parameters that were used for the search */
    query?: IGetQuery;
    /** Sort information for the current page */
    sort: {
        /** Whether data is sorted (true if sorting is applied) */
        sorted: boolean;
        /** Whether data is unsorted (true if no sorting is applied) */
        unsorted: boolean;
        /** Whether sort configuration is empty (true if no sort parameters exist) */
        empty: boolean;
    };
}
/**
 * Type for image categories
 * Represents different types of images that can be stored in the system
 * - 'pp': Profile pictures
 * - 'other': Other image types
 */
type ImageType = 'pp' | 'other';
/**
 * Interface for tab configuration
 * Defines the structure for tabs in tabbed interfaces
 */
interface ITab {
    /** Unique identifier for the tab */
    id?: string;
    /** Target element or route to navigate to when tab is selected */
    target?: string;
    /** Display label for the tab */
    label: string;
    /** Form identifier associated with the tab */
    form?: string;
    /**
     * Function to execute when posting data from the tab
     * @param data The data to be posted
     * @param productCode Optional product code associated with the data
     * @returns Observable containing the posted data and product code
     */
    postFunction?: (data: any, productCode?: string) => Observable<{
        /** The posted data returned from the server */
        data: any;
        /** Product code associated with the posted data */
        productCode: string;
    }>;
    /**
     * Function to execute when updating data from the tab
     * @param data The data to be updated
     * @param productCode Product code associated with the data
     * @returns Observable containing the updated data and product code
     */
    putFunction?: (data: any, productCode: string) => Observable<{
        /** The updated data returned from the server */
        data: any;
        /** Product code associated with the updated data */
        productCode: string;
    }>;
    /** Data associated with the tab */
    data?: any;
}
/**
 * Interface for custom validation errors
 * Defines possible validation error types that can be returned from validators
 */
interface CustomValidationError {
    /** Custom error message for application-specific validation */
    custom?: string;
    /** Whether the value is invalid for general reasons */
    invalid?: boolean;
    /** Whether the value exceeds maximum length */
    maxlength?: boolean;
    /** Alternative property for maximum length validation */
    maxLength?: boolean;
    /** Whether the value is below minimum length */
    minlength?: boolean;
    /** Alternative property for minimum length validation */
    minLength?: boolean;
    /** Whether the referenced entity was not found */
    notFound?: boolean;
    /** Whether the value is not unique when uniqueness is required */
    notUnique?: boolean;
    /** Whether the value fails pattern validation */
    pattern?: boolean;
    /** Whether a required value is missing */
    required?: boolean;
    /** Whether the value is already in use */
    used?: boolean;
}
/**
 * Enum for menu types
 * Defines the orientation of menus in the UI
 */
declare enum EMenuType {
    /** Horizontal menu layout */
    horizontal = "H",
    /** Vertical menu layout */
    vertical = "V"
}
/**
 * Interface for items with value and label
 * Common pattern for dropdown options and other selectable items
 * @template T Type of the value
 */
interface IValueLabel<T = string> {
    /** Value to be used programmatically (e.g., stored in database) */
    value: T;
    /** Human-readable display label for the value */
    label: string;
}
/**
 * Interface for image configuration
 * Defines paths and settings for various image assets used in the application
 */
interface IConfigImages {
    /** Path to favicon image displayed in browser tabs */
    favicon: {
        /** Dark theme logo path */
        dark: string;
        /** Light theme logo path */
        light: string;
    };
    /** Path to watermark image used for document overlays */
    watermark?: string;
    /** Logo image paths for different themes */
    logo: {
        /** Dark theme logo path */
        dark: string;
        /** Light theme logo path */
        light: string;
    };
    /** Profile picture configuration */
    pp?: {
        /** Source path for full-size profile pictures */
        src: string;
        /** Path for minimized/thumbnail profile pictures */
        min: string;
    };
    /** Other image configuration */
    other?: {
        /** Source path for full-size images */
        src: string;
        /** Path for minimized/thumbnail images */
        min: string;
    };
}
/**
 * Class for constant values
 * Container for application-wide constant values
 */
declare class Constant {
}
/**
 * Interface for database table names
 * Defines the schema and table names for database operations
 */
interface ITableName {
    /** Database schema name */
    schema: string;
    /** Primary table name */
    primaryTable: string;
}
/**
 * Interface for items with type and description
 * Common pattern for categorized items with descriptions
 */
interface ITypeDescription {
    /** Description text explaining the item */
    description: string;
    /** Type identifier categorizing the item */
    type: string;
}
/**
 * Interface for service functions
 * Defines common methods that services should implement
 */
interface IServiceFunction {
    /**
     * Base function that other service methods may build upon
     * @param args Variable arguments passed to the function
     * @returns Any value depending on implementation
     */
    _base?: (...args: any[]) => any;
    /**
     * Search function to retrieve data based on criteria
     * @param args Variable arguments for search parameters
     * @returns Observable containing search results
     */
    search: (...args: any[]) => Observable<any>;
    /**
     * Create function to add new data
     * @param args Variable arguments for creation parameters
     * @returns Observable containing the created entity
     */
    create: (...args: any[]) => Observable<any>;
}
/**
 * JavaScript primitive and object types
 * Union type of all possible JavaScript typeof results
 */
type TypeOf = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
/**
 * Status values for processes or tasks
 * Represents the current state of a process or task in the system
 * - 'COMPLETED': The process has finished successfully
 * - 'PENDING': The process is still in progress
 */
type Status = 'COMPLETED' | 'PENDING';
/**
 * Type for strictly typed form groups
 * Provides type safety for Angular form groups by ensuring form controls match the data model
 * @template T Type of the form data model
 */
type IStrictFormGroup<T> = {
    [x in keyof T]: FormControl<T[x]>;
};
/**
 * Interface for generic object literals
 * Represents objects with string keys and values of a specified type
 * @template TValue Type of the values in the object (defaults to any)
 */
interface IObjectLiteral<TValue = any> {
    /** Object properties with string keys and values of type TValue */
    [x: string]: TValue;
}
/**
 * Interface for file with metadata
 * Represents a file upload with associated document metadata
 */
interface IFile_Metadata {
    /** File object containing the actual file data */
    file: File;
    /** Document metadata describing the file's purpose and categorization */
    metadata: IDocMetadata;
}
/**
 * Subtypes for input components
 * Represents specialized input types for specific data formats
 * - 'money': Input formatted as currency
 */
type InputSubType = 'money';
/**
 * Utility type that extracts keys from T where the value is of type TExpectedFieldType
 * Filters object properties to only those matching a specific type
 * @template T Source object type
 * @template TExpectedFieldType Expected type of the field values to include
 */
type KeyOfType<T, TExpectedFieldType> = keyof {
    [P in keyof T as T[P] extends TExpectedFieldType ? P : never]: any;
};

/**
 * Abstract base class for SDK environment configuration.
 * Provides core functionality for application settings, routing, translation, and UI state management.
 */
declare abstract class SDKEnvironment {
    production: boolean;
    /** Application routes configuration */
    appRoutes?: any;
    /** List of active systems in the application */
    activeSystems: any[];
    /** Items to display in the bottom menu */
    bottomMenu: any[];
    /** Currently active system */
    currentSystem: any;
    /** Map of menus to exclude from display */
    excludedMenus: Map<string, any>;
    /** Whether to log HTTP requests */
    logReq: boolean;
    /** Application menu items */
    menus: any[];
    /** Whether to skip user role validation checks */
    noUserRoleCheck: boolean;
    /** Title displayed in the browser tab */
    pageTitle: string;
    /** Environment name identifier */
    name: string;
    /**
     * The storage key for the last timestamp an update was found
     */
    readonly lastUpdateTimeStorageKey = "lastUpdateTime";
    /**
     * The storage key for the last timestamp an update was checked
     */
    readonly lastUpdateCheckTimeStorageKey = "lastUpdateCheckTime";
    /**
     * Last timestamp an update was found
     */
    lastUpdateTime: number;
    /**
     * Last timestamp an update was checked
     */
    lastUpdateCheckTime: number;
    /** Configuration for application images */
    images: IConfigImages;
    /** Storage key for target language preference */
    readonly targetLanguageKey = "targetLanguage";
    /** Storage key for translation glossary */
    readonly transGlossaryKey: string;
    /** Storage key for translation settings */
    readonly translateKey = "translate";
    /** Storage key for user company configuration */
    readonly userCompanyConfigKey = "userCompanyConfig";
    /** Storage key for user menu preferences */
    readonly userMenuKey = "userMenu";
    /** Whether the application should enforce single tab usage */
    singleTabUsage: boolean;
    /** Whether to log user activities */
    logActivities: boolean;
    /** Storage mechanism to use (localStorage or sessionStorage) */
    storageKey: 'localStorage' | 'sessionStorage';
    /** Translation glossary data */
    transGlossary: any;
    /** User company configuration data */
    userCompanyConfig: any;
    /** Whether to use error reporting tools like Sentry */
    reportError: boolean;
    /**
     * Specify whether to use container or container-fluid for the body of the view.
     * Should be unset in the ngOnDestroy function.
     */
    wideScreen: boolean;
    /**
     * Request timeout duration in milliseconds or as a Date object
     */
    requestTimeout: number | Date;
    /** Whether the application has already been opened */
    alreadyOpened: boolean;
    /** Configuration for busline integration */
    useBusline: any;
    /** Whether to use the user menu */
    useUserMenu: boolean;
    /**
     * Additional CSS class(es) to add to the body element.
     * Should be unset in the ngOnDestroy function.
     */
    bodyClass: string;
    /** Page loader instance for managing loading states */
    pageLoader: PageLoader;
    /** Subject for tracking HTTP request loading state */
    readonly requestLoader$: ReplaySubject<boolean>;
    /** Counter for active HTTP requests */
    requestCount: number;
    /** Whether the application uses Active Directory authentication */
    usingActiveDirectory: boolean;
    /** Current activated route */
    activatedRoute: ActivatedRoute;
    /** Storage key for application logs */
    readonly logsKey = "logs";
    /** Base URL for API requests */
    apiBaseUrl?: string;
    /** Application name */
    appName: string;
    /** Whether authentication is required */
    authenticate?: boolean;
    /** Whether debug mode is enabled */
    debug?: boolean;
    /** URL for help documentation */
    readonly helpLink = "https://help.evoluticstech.com/";
    /** Storage key for user profile data */
    readonly userProfileKey = "userProfile";
    /** Storage key for user authentication data */
    readonly userStorageKey = "user";
    /** Optional watermark text to display */
    readonly watermark?: string;
    /** Source language code */
    sourceLanguage: string;
    /** Secret key for encryption/security */
    secretKey: string;
    /** Application version number */
    versionNo?: string;
    /** API key for Sentry error tracking */
    sentryKey?: string;
    /**
     * Gets the authentication token
     * @returns The authentication token or null if not available
     */
    get token(): any;
    /**
     * Sets the loading state of the application
     * @param v Whether the application is loading
     */
    set loading(v: boolean);
    /**
     * Creates a new environment instance
     * @param production Whether the application is running in production mode
     * @param name Environment name identifier
     */
    constructor(production: boolean, name: string);
    /** Internal storage for translation setting */
    protected _translate?: boolean;
    /**
     * Gets whether translation is enabled
     * @returns The translation enabled state
     */
    get translate(): boolean;
    /**
     * Sets whether translation is enabled
     * @param value The new translation enabled state
     */
    set translate(value: boolean);
    /** Internal storage for target language */
    _targetLanguage?: string;
    /**
     * Gets the target language for translations
     * @returns The target language code
     */
    get targetLanguage(): string;
    /**
     * Sets the target language for translations
     * @param value The new target language code
     */
    set targetLanguage(value: string);
    /**
     * Reinitializes the environment object with new settings
     * @param env New environment object to use to reset this object
     */
    reinit(env: any): void;
}
/**
 * Concrete implementation of SDKEnvironment with typed properties
 * for systems, routes, menus and language settings.
 */
declare class Environment extends SDKEnvironment {
    production: boolean;
    activeSystems: ESystem[];
    appRoutes: AppRouteBase;
    menus: any[];
    currentSystem: ESystem;
    sourceLanguage: ELanguage;
    /**
     * Creates a new environment instance
     * @param production Whether the application is running in production mode
     * @param name Environment name identifier
     */
    constructor(production: boolean, name: string);
    _targetLanguage?: ELanguage;
    /**
     * Gets the target language for translations
     * @returns The target language code
     */
    get targetLanguage(): ELanguage;
    /**
     * Sets the target language for translations
     * @param value The new target language code
     */
    set targetLanguage(value: ELanguage);
}

/**
 * Represents the time format type.
 * - '12H': 12-hour format with AM/PM
 * - '24H': 24-hour format
 */
type ETimeType = '12H' | '24H';
/**
 * Configuration interface for input components.
 */
interface IInputConfig {
    /**
     * Specifies the time format to be used in time-related inputs.
     * Can be either 12-hour format ('12H') or 24-hour format ('24H').
     */
    timeType: ETimeType;
}
type OptionLabelType = 'acd' | 'bnk' | 'ccd' | 'cd' | 'cdt' | 'cf' | 'cg' | 'cl' | 'cmd' | 'cn' | 'ct' | 'cu' | 'gd' | 'ha' | 'id' | 'if' | 'ifl' | 'il' | 'it' | 'md' | 'na' | 'pd' | 'pep' | 'pam' | 'nf' | 'td' | 'title' | 'ud' | 'uf' | 'vl' | 'vv';

interface IFormOptions {
    [field: string]: any;
}
/**
 * Interface for form field schema configuration
 *
 * @template T - Type of the form data
 * @template Component - Type of the form generator component
 * @template TFormGroup - Type of the form group
 */
interface IBaseFormSchema<T, Component, TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any> {
    /** Unique identifier for the form field */
    _id?: string;
    /** Asynchronous validators to apply to the form control */
    asyncValidators?: AsyncValidatorFn[];
    /** When true, automatically determines the value field from available options */
    autoPickValueField?: boolean;
    /** Whether the field is checked (for checkbox inputs) */
    checked?: boolean;
    /** Child form fields for nested forms */
    children?: IBaseFormSchema<T, Component, TFormGroup>[];
    /** When true, clears the field value when it becomes disabled */
    clearOnDisable?: boolean;
    /** Additional CSS classes to apply to the field container */
    cls?: string;
    /** Three-letter country code for phone number fields */
    countryCode3?: string;
    /** Enables debug mode for this specific field */
    debug?: boolean;
    /** Number of decimal points to display for number inputs */
    decimalPoints?: number;
    /** Whether the field is disabled */
    disabled?: boolean;
    /** Function that determines if the field should be disabled based on form values */
    disabledIf?: (row: any, cellField?: string) => boolean;
    /** When true, prevents automatic formatting of the input value */
    dontFormatAsInput?: boolean;
    /** Label to display at the end of the input */
    endLabel?: string;
    /** Tooltip text for the end label */
    endLabelTooltip?: string;
    /** Additional data to associate with this field */
    extra?: any;
    /** The name of the form field (required) */
    field: keyof TFormGroup;
    /** Reference to the form group this field belongs to */
    form?: FormGroup<TFormGroup>;
    /** Function to format the display value of the field */
    formatter?: (row: {
        [K in keyof TFormGroup]: any;
    }, fieldName: keyof TFormGroup) => string;
    /** Key to use when retrieving country code */
    getCountryCode3Key?: string;
    /** Whether the field should be hidden */
    hidden?: boolean;
    /** Hint text to display below the field */
    hint?: string;
    /** Icon to display with the field */
    icon?: IconType;
    /** HTML ID attribute for the field */
    id?: string;
    /** When true, excludes this field from the form schema */
    ignore?: boolean;
    /** Whether the field is required */
    isRequired?: boolean;
    /** Whether this field should be used for searching */
    isSearchField?: boolean;
    /** Display label for the field */
    label?: string;
    /** Field(s) to use as the label when displaying options */
    labelField?: string | string[];
    /** Type of label to display for options */
    labelType?: OptionLabelType;
    /** Maximum value for number inputs */
    max?: number;
    /** Maximum length for text inputs */
    maxLength?: number;
    /** Minimum value for number inputs */
    min?: number;
    /** Minimum length for text inputs */
    minLength?: number;
    /** When true, prevents formatting of the field value */
    noFormat?: boolean;
    /** Function called when the field value changes */
    onChangeFunc?: IfFunc<T, TFormGroup, Component, any>;
    /** Function called when any form value changes */
    onFormChange?: IfFunc<T, TFormGroup, Component, any>;
    /** RxJS operators to apply to the form change stream */
    onFormChangePipeOperators?: () => OperatorFunction<any, any>;
    /** Function called when the field is removed */
    onRemoveFunc?: IfFunc<T, TFormGroup, Component, any>;
    /** Function to format individual options */
    optionFormatter?: (item: any) => string;
    /** Array of options for select/dropdown fields */
    options?: any[];
    /** Observable or Promise that resolves to an array of options */
    optionsAsync?: Observable<any[]> | Promise<any[]>;
    /** Function that returns an Observable of options */
    optionsFunc?: (...val: any) => Observable<any[]>;
    /** Observable that provides initial options */
    optionsInitFunc?: Observable<any[]>;
    /** Function that returns an Observable for initial options */
    optionsInitFunc2?: () => Observable<any[]>;
    /** Key to use when retrieving options from a data source */
    optionsKey?: string;
    /** Placeholder text for the input */
    placeholder?: string;
    /** Function to perform search operations */
    searchFunc?: (...args: any[]) => any;
    /** Label for the currently selected option */
    selectedOptionLabel?: string;
    /** When true, sets the field value as a country code */
    setAsCountryCode3?: boolean;
    /** When true, sets the formatted value in the form control */
    setControlFormattedValue?: boolean;
    /** Whether to show a required indicator tag */
    showRequiredTag?: boolean;
    /** Whether to show validation state */
    showValidation?: boolean;
    /** Whether to show validation state icon */
    showValidationIcon?: boolean;
    /** Whether to show validation error messages */
    showValidationMsg?: boolean;
    /** When true, skips checking if the selected option exists in options list */
    skipDoesOptionExistCheck?: boolean;
    /** Whether the label should be stacked above the input */
    stacked?: boolean;
    /** Function to format the field value for table display */
    tableFormatter?: (val: any) => string | undefined | Promise<string | undefined> | Observable<string | undefined>;
    /** Value to use when rendering with a template */
    templateValue?: any;
    /** When true, triggers the onChange function during initialization */
    triggerOnChangeOnInit?: boolean;
    /** Type of input to render */
    type?: InputType;
    /** Synchronous validators to apply to the form control */
    validators?: ValidatorFn[];
    /** Default value for the field */
    value?: any;
    /** Field to use as the value when working with options */
    valueField?: string;
    /** When true, enables verbose logging for this field */
    verbose?: boolean;
    accept?: string;
}
type IfFunc<T, TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
}, Component, TResponse> = (row: {
    [K in keyof TFormGroup]?: TFormGroup[K]['value'];
}, cellValue?: any, component?: Component) => TResponse;

/**
 * Namespace containing form-related utilities and configurations
 */
declare namespace ETSForms {
    /**
     * Class providing form control creation and validation utilities
     */
    class ConfigForms {
        /**
         * Validates that two form fields have matching values
         * @param formGroup - The form group containing the fields to compare
         * @param field1 - The name of the first field (defaults to 'password')
         * @param field2 - The name of the second field (defaults to 'rpassword')
         */
        matches(formGroup: FormGroup, field1?: string, field2?: string): void;
        /**
         * Returns a validator function that checks if two fields match
         * @param formGroup - The form group containing the fields to compare
         * @param field1 - The name of the first field
         * @param field2 - The name of the second field
         * @returns null if fields match, otherwise an error object
         */
        matches2(formGroup: any, field1: string, field2: string): {
            noMatch: boolean;
        };
        /**
         * Creates a form control for email input with validation
         * @param required - Whether the field is required (default: true)
         * @param value - Initial value (default: null)
         * @returns FormControl with email validation
         */
        email<T = any>(required?: boolean, value?: any): FormControl<T>;
        /**
         * Creates a form control for name input with validation
         * @param required - Whether the field is required (default: true)
         * @param minLength - Minimum length requirement (default: 2)
         * @param value - Initial value (default: null)
         * @returns FormControl with name validation
         */
        name<T = any>(required?: boolean, minLength?: number, value?: any): FormControl<T>;
        /**
         * Creates a form control for array values
         * @param required - Whether the field is required (default: false)
         * @param value - Initial array value (default: empty array)
         * @returns FormControl for array data
         */
        array<T = any>(required?: boolean, value?: T[]): FormControl<T[]>;
        /**
         * Creates a form control for boolean values
         * @param required - Whether the field is required (default: false)
         * @param value - Initial boolean value (default: false)
         * @returns FormControl for boolean data
         */
        boolean(required?: boolean, value?: boolean): FormControl<boolean>;
        /**
         * Creates a form control for username input with validation
         * @param required - Whether the field is required (default: true)
         * @param minLength - Minimum length requirement (default: 3)
         * @param maxLength - Maximum length requirement (default: 10)
         * @param value - Initial value (default: null)
         * @returns FormControl with username validation
         */
        username<T = string>(required?: boolean, minLength?: number, maxLength?: number, value?: any): FormControl<T>;
        /**
         * Creates a generic form control with custom validation
         * @param value - Initial value
         * @param validatorOrOpts - Validators or options
         * @param asyncValidator - Async validators
         * @returns Generic FormControl
         */
        default<T = any>(value?: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[]): FormControl<T>;
        /**
         * Creates a form control for number input with validation
         * @param required - Whether the field is required (default: false)
         * @param value - Initial value (default: null)
         * @param maxLength - Maximum length (default: 100000)
         * @returns FormControl with number validation
         */
        number<T = number>(required?: boolean, value?: any, maxLength?: number): FormControl<T>;
        /**
         * Creates a form control for integer input with validation
         * @param required - Whether the field is required (default: true)
         * @param value - Initial value (default: null)
         * @param maxLength - Maximum length (default: 100000)
         * @returns FormControl with integer validation
         */
        integer<T = number>(required?: boolean, value?: any, maxLength?: number): FormControl<T>;
        /**
         * Creates a form control for postal code input with validation
         * @param required - Whether the field is required (default: true)
         * @param value - Initial value (default: null)
         * @returns FormControl with postal code validation
         */
        postalCode<T = any>(required?: boolean, value?: any): FormControl<T>;
        /**
         * Creates a form control for phone number input with validation
         * @param required - Whether the field is required (default: true)
         * @param value - Initial value (default: null)
         * @returns FormControl with phone number validation
         */
        phone<T = string>(required?: boolean, value?: any): FormControl<T>;
        /**
         * Creates a required form control with minimum length validation
         * @param length - Minimum length requirement
         * @param value - Initial value (default: null)
         * @returns FormControl with required and min length validation
         */
        requiredMinLength<T = any>(length: number, value?: any): FormControl<T>;
        /**
         * Creates a required form control with minimum and maximum length validation
         * @param min - Minimum length requirement
         * @param max - Maximum length requirement
         * @returns FormControl with required, min and max length validation
         */
        requiredMinMaxLength<T = any>(min: number, max: number): FormControl<T>;
        /**
         * Creates a required form control
         * @param value - Initial value (default: null)
         * @returns FormControl with required validation
         */
        required<T = any>(value?: any): FormControl<T>;
        /**
         * Creates a form control with minimum length validation
         * @param length - Minimum length requirement (default: 3)
         * @param value - Initial value (default: null)
         * @returns FormControl with min length validation
         */
        minLength<T = any>(length?: number, value?: any): FormControl<T>;
        /**
         * Creates a form control for URL input with validation
         * @param value - Initial value (default: null)
         * @param required - Whether the field is required (default: true)
         * @returns FormControl with URL validation
         */
        url<T = any>(value?: any, required?: boolean): FormControl<T>;
        /**
         * Creates a form control with custom pattern validation
         * @param pattern - Regular expression pattern for validation
         * @param required - Whether the field is required (default: false)
         * @param value - Initial value
         * @returns FormControl with pattern validation
         */
        pattern<T = any>(pattern: RegExp, required?: boolean, value?: any): FormControl<T>;
    }
}
/**
 * Singleton instance of ConfigForms
 */
declare const configForms: ETSForms.ConfigForms;
/**
 * Collection of regular expression patterns for form validation
 */
declare const configPatterns: {
    /** Pattern for validating dates */
    date: RegExp;
    /** Pattern for validating email addresses */
    email: RegExp;
    /** Pattern for validating integers */
    integer: RegExp;
    /** Pattern for validating names */
    name: RegExp;
    /** Pattern for validating numbers */
    number: RegExp;
    /** Pattern for validating phone numbers */
    phone: RegExp;
    /** Pattern for validating postal codes */
    postal: RegExp;
    /** Pattern for validating URLs */
    url: RegExp;
    /** Pattern for validating usernames */
    username: RegExp;
    /** Pattern for validating website URLs */
    website: RegExp;
};

/**
 * Base interface for ETS menu items
 * @template TESystemType - The system type, defaults to ESystem
 * @template TESubSystem - The subsystem type, defaults to ESubSystem
 * @template TEMenuLocation - The menu location type, defaults to EMenuLocation
 */
interface IETSMenuItemBase<TESystemType = ESystem, TESubSystem = ESubSystem, TEMenuLocation = EMenuLocation> {
    /** Breadcrumb navigation items */
    breadcrumbs?: KeyValue<string, string>[];
    /** String representation of breadcrumbs */
    breadcrumbsStr?: string;
    /** Indicates if the menu item has sub-items */
    hasSub?: boolean;
    /** Icon identifier for the menu item */
    icon?: string;
    /** Unique identifier for the menu item */
    id?: string;
    /** Position index of the menu item */
    index?: number;
    /** Indicates if the menu item is a divider */
    isDivider?: boolean;
    /** Indicates if the menu item is a parent */
    isP?: boolean;
    /** Display text for the menu item */
    label?: string;
    /** Lowercase version of the label for case-insensitive operations */
    labelLowerCase?: string;
    /** Navigation link for the menu item */
    link?: string;
    /** Nesting level of the menu item */
    level?: number;
    /** Map of locations where this menu item appears */
    locations?: Map<TEMenuLocation, boolean>;
    /** ID of the parent menu item */
    parentID?: string;
    /** Position of the submenu relative to the parent */
    submenuPosition?: MenuPositionX;
    /** Subsystem this menu item belongs to */
    subSystem?: TESubSystem;
    /** System this menu item belongs to */
    system?: TESystemType;
    /** Icon for the system */
    systemIcon?: string;
    /** Link to the system */
    systemLink?: string;
}
/**
 * Interface for raw menu item collections
 */
interface IETSMenuItemRawBase {
    [x: string]: IETSMenuItemRaw;
}
/**
 * Interface for raw menu items with nested structure
 */
interface IETSMenuItemRaw extends IETSMenuItemBase {
    /** Nested submenu items in object format */
    subs?: {
        [x: string]: IETSMenuItemRaw;
    };
}
/**
 * Interface for processed menu items
 * @template TESystemType - The system type, defaults to ESystem
 * @template TESubSystem - The subsystem type, defaults to ESubSystem
 * @template TEMenuLocation - The menu location type, defaults to EMenuLocation
 */
interface IETSMenuItem<TESystemType = ESystem, TESubSystem = ESubSystem, TEMenuLocation = EMenuLocation> extends IETSMenuItemBase<TESystemType, TESubSystem, TEMenuLocation> {
    /**
     * Array of submenu items
     * @deprecated
     */
    subs?: IETSMenuItem<TESystemType, TESubSystem, TEMenuLocation>[];
}
/**
 * Class implementation of menu items with additional functionality
 * @template TESystemType - The system type, defaults to ESystem
 * @template TESubSystem - The subsystem type, defaults to ESubSystem
 * @template TEMenuLocation - The menu location type, defaults to EMenuLocation
 */
declare class ETSMenuItem<TESystemType = ESystem, TESubSystem = ESubSystem, TEMenuLocation = EMenuLocation> implements IETSMenuItem<TESystemType, TESubSystem, TEMenuLocation> {
    /** Breadcrumb navigation items @deprecated */
    breadcrumbs?: KeyValue<string, string>[];
    /** String representation of breadcrumbs */
    breadcrumbsStr?: string;
    /** Indicates if the menu item has sub-items */
    hasSub?: boolean;
    /** Icon identifier for the menu item */
    icon: string;
    /** Unique identifier for the menu item */
    id: string;
    /** Position index of the menu item */
    index?: number;
    /** Indicates if the menu item is a divider */
    isDivider?: boolean;
    /** Indicates if the menu item is a parent */
    isP?: boolean;
    /** Display text for the menu item */
    label: string;
    /** Lowercase version of the label for case-insensitive operations */
    labelLowerCase?: string;
    /** Nesting level of the menu item */
    level?: number;
    /** Navigation link for the menu item */
    link: string;
    /** Map of locations where this menu item appears */
    locations?: Map<TEMenuLocation, boolean>;
    /** ID of the parent menu item */
    parentID: string;
    /** Position of the submenu relative to the parent */
    submenuPosition?: MenuPositionX;
    /** Subsystem this menu item belongs to */
    subSystem: TESubSystem;
    /** System this menu item belongs to */
    system: TESystemType;
    /** Icon for the system */
    systemIcon?: string;
    /** Link to the system */
    systemLink?: string;
    /** Database ID for the menu item */
    dbID: number;
    /** Indicates if the menu item is disabled */
    disabled: boolean;
    /** Array of submenu items */
    subs: ETSMenuItem<TESystemType, TESubSystem, TEMenuLocation>[];
    /** Indicates if the user has view access to this menu item */
    viewAccess: boolean;
    /** Indicates if the user has edit access to this menu item */
    editAccess: boolean;
    /**
     * Gets the edit access status
     * @returns Current edit access status
     */
    get _editAccess(): boolean;
    /**
     * Sets the edit access status and propagates to submenu items
     * @param value - New edit access status
     */
    set _editAccess(value: boolean);
    /**
     * Gets the view access status
     * @returns Current view access status
     */
    get _viewAccess(): boolean;
    /**
     * Sets the view access status and propagates to submenu items
     * @param value - New view access status
     */
    set _viewAccess(value: boolean);
    /**
     * Creates a new menu item
     * @param menuItem - Source menu item data
     * @param parent - Optional parent menu item
     */
    constructor(menuItem: IETSMenuItem<TESystemType, TESubSystem, TEMenuLocation>, parent?: IETSMenuItem<TESystemType, TESubSystem, TEMenuLocation>);
    /**
     * Toggles the disabled state of the menu item
     */
    toggle(): void;
    /**
     * Toggles view access for this menu item
     */
    toggleView(): void;
    /**
     * Toggles edit/create access for this menu item
     */
    toggleCreate(): void;
    /**
     * Grants edit access to this menu item and all its submenu items
     */
    allowEditAllSubMenus(): void;
    /**
     * Removes edit access from this menu item and all its submenu items
     */
    disableEditAllSubMenus(): void;
    /**
     * Grants view access to this menu item and all its submenu items
     */
    allowViewAllSubMenus(): void;
    /**
     * Removes view access from this menu item and all its submenu items
     */
    disableViewAllSubMenus(): void;
    /**
     * Toggles edit access for this menu item and all its submenu items
     */
    toggleEditAllSubMenus(): void;
    /**
     * Toggles view access for this menu item and all its submenu items
     */
    toggleViewAllSubMenus(): void;
    /**
     * Grants both view and edit access to this menu item
     */
    allowAuthorization(): void;
    /**
     * Removes both view and edit access from this menu item
     */
    disableAuthorization(): void;
    /**
     * Toggles both view and edit access for this menu item
     */
    toggleAuthorization(): void;
}
/**
 * Special menu item class that represents a divider
 */
declare class ETSMenuItemDivider extends ETSMenuItem {
    /**
     * Creates a new divider menu item
     */
    constructor();
}
/**
 * Enum for page button IDs
 */
declare enum EETSPageBtnID {
    agentCommissions = "PAC8",
    agentCreditNotes = "PACN10",
    agentDocuments = "PAD2",
    agentEndorsements = "PAE3",
    agentLoan = "PAL1",
    agentNotes = "PAN6",
    agentPendingQuotes = "PAPQ11",
    agentPolicies = "PAP7",
    agentProduction = "PAP9",
    agentWebLogIn = "PAWL4",
    agentWorkflows = "PAW5",
    agentCalendar = "PAC6",
    agentFutureActions = "PAFA23",
    clientCalendar = "PCC11",
    clientDocuments = "PCD12",
    clientEndorsements = "PCE13",
    clientNotes = "PCN14",
    clientOtherBusiness = "PCOB15",
    clientPendingPayments = "PCPP16",
    clientPendingQuotes = "PCPQ17",
    clientPolicies = "PCP18",
    clientRelationships = "PCR19",
    clientUnderwritingEvents = "PCUE20",
    clientWebLogIn = "PCWL21",
    clientWorkflows = "PCW22",
    clientFutureActions = "PCFA23"
}

/**
 * Configuration options for the translator service.
 */
interface ITranslatorConfig {
    /**
     * When true, the translation request will be ignored.
     */
    ignore?: boolean;
    /**
     * When true, enables debug mode for the translator.
     */
    debug?: boolean;
    /**
     * When true, prevents the loader from being displayed during translation.
     */
    noLoader?: boolean;
    /**
     * When true, displays a minimal version of the loader during translation.
     */
    miniLoader?: boolean;
    /**
     * Process this request without merging it with other items.
     *
     * It will still be processed in the queue.
     */
    singleHandle?: boolean;
}

declare namespace EVFunctions {
    /**
     * Removes 'null' strings from text
     * @param text - The string to process
     * @returns The processed string with 'null' strings removed or the original text if null/undefined
     */
    function stripNull(text: string): any;
    /**
     * Creates route redirects for a given route
     * @param route - The target route to redirect to
     * @param redirects - Array of redirect configurations
     * @returns An array of routes including the redirects and the original route
     */
    function routeRedirects(route: Route, redirects: {
        /**
         * The path to match against. Cannot be used together with a custom `matcher` function.
         * A URL string that uses router matching notation.
         * Can be a wild card (`**`) that matches any URL (see Usage Notes below).
         * Default is "/" (the root path).
         *
         */
        path: string;
        /**
         * The path-matching strategy, one of 'prefix' or 'full'.
         * Default is 'prefix'.
         *
         * By default, the router checks URL elements from the left to see if the URL
         * matches a given path and stops when there is a config match. Importantly there must still be a
         * config match for each segment of the URL. For example, '/team/11/user' matches the prefix
         * 'team/:id' if one of the route's children matches the segment 'user'. That is, the URL
         * '/team/11/user' matches the config
         * `{path: 'team/:id', children: [{path: ':user', component: User}]}`
         * but does not match when there are no children as in `{path: 'team/:id', component: Team}`.
         *
         * The path-match strategy 'full' matches against the entire URL.
         * It is important to do this when redirecting empty-path routes.
         * Otherwise, because an empty path is a prefix of any URL,
         * the router would apply the redirect even when navigating
         * to the redirect destination, creating an endless loop.
         *
         */
        pathMatch?: 'prefix' | 'full';
    }[]): Route[];
    /**
     * @deprecated Please use extendRoute2 instead
     * @param route
     * @param indexComponent
     * @param indexLazyModule
     * @example
     * ```ts
     * EVFunctions.extendRoute(
     *  {
     *     path: '',
     *     data: { title: 'CRM / Setups / Segment' },
     *     loadChildren: () => import('./create-segment/create-segment.module')
     *       .then((m) => m.CreateSegmentModule),
     *  },
     *  null,
     *  () => import('./segments-index/segments-index.module')
     *     .then((m) => m.SegmentsIndexModule));
     * ```
     * @returns
     */
    function extendRoute(route: Route, indexComponent?: Type<any>, indexLazyModule?: LoadChildrenCallback): Routes;
    type IExtendRouteIndexPage = Route & {
        component?: Type<any>;
        /**@deprecated */
        lazyComponent?: () => Type<unknown> | Observable<Type<unknown> | DefaultExport<Type<unknown>>> | Promise<Type<unknown> | DefaultExport<Type<unknown>>>;
        /**@deprecated */
        lazyModule?: LoadChildrenCallback;
        redirectToIndex?: boolean;
        title?: string;
        hideTitle?: boolean;
    };
    /**
     *
     * @param route
     * @param indexPage
     * @example
     * ```ts
     * EVFunctions.extendRoute2(
      {
        path: '',
        data: { title: ' Process Actions' },
        loadComponent: () =>
          import('./create-process-actions/create-process-actions.component').then(
            (c) => c.CreateProcessActionsComponent
          ),
      },
      { component: IndexProcessActionsComponent }
    )
     * ```
     * @returns
     */
    function extendRoute2(route: Route, indexPage?: IExtendRouteIndexPage): Routes;
    function createModule(path: string, route: Omit<Route, 'path'>, indexPage?: IExtendRouteIndexPage): Route;
    /**
     * Concatenates two strings and accounts for null values
     * @param text1 First string to concatenate
     * @param text2 Second string to concatenate
     * @param joinerText String to place in between the two texts
     * @returns
     */
    function strConcatenator(text1?: string, text2?: string, joinerText?: string): {
        value: string;
        label: string;
    };
    /**
     * Concatenates two strings and accounts for null values
     * @param values Array of strings to concatenate
     * @param joinerText String to place in between the two texts
     * @returns
     */
    function strConcatenator2(values?: (string | number | boolean)[], joinerText?: string): string;
    /**
     * Concatenates two strings and accounts for null values
     * @param text1 First string to concatenate
     * @param text2 Second string to concatenate
     * @param joinerText String to place in between the two texts
     * @returns
     */
    function strConcatenator2(text1?: string | number | boolean, text2?: string | number | boolean, joinerText?: string): string;
    /**
     * Generates a RFC4122 version 4 compliant UUID
     * @returns A randomly generated UUID string
     */
    const generateUUID: () => string;
    /**
     * Creates a redirect route for user management
     * @param route - The original route to modify
     * @param prefix - The prefix to add to the route path
     * @returns An array of routes including the redirect and the modified route
     */
    function redirectRouteForUM(route: Route, prefix: string): Routes;
    /**
     * Type casting utility function that returns the input value with its type preserved
     * @param value - The value to cast
     * @returns The same value with its type information preserved
     * @typeParam T - The type of the value
     */
    function typeCaster<T>(value: T): T;
}

/**
 * Configuration class containing application-wide constants and settings
 */
declare class Config {
    /** Configuration for application images */
    static Images?: IConfigImages;
    /**
     * List of options with numeric and letter identifiers
     * Used for multiple choice options
     */
    static Optioner: {
        num: number;
        letter: string;
    }[];
    /**
     * List of months with various format representations
     */
    static Months: {
        id: number;
        short: string;
        isoStr: string;
        long: string;
    }[];
    /**
     * Map of months by lowercase short name
     */
    static ShortMonthsMap: {
        [k: string]: {
            id: number;
            short: string;
            isoStr: string;
            long: string;
        };
    };
    /**
     * Map of months by ISO string representation
     */
    static MonthsIsoStrMap: {
        [k: string]: {
            id: number;
            short: string;
            isoStr: string;
            long: string;
        };
    };
    /**
     * List of days of the week with index values
     */
    static Days: {
        index: number;
        day: Day;
    }[];
    /**
     * List of ordinal number representations
     */
    static Numbers: {
        num: number;
        label: string;
    }[];
    /** Available sex/gender options */
    static sexes: string[];
    /**
     * Boolean options with human-readable titles
     * @readonly
     */
    static readonly boolList: ICodeTitle<boolean>[];
    /** Currency symbol for the application */
    static Currency: string;
    /** Timestamp representing one day in milliseconds */
    static TimeStampDay: number;
    /** Timestamp representing one week in milliseconds */
    static TimeStampWeek: number;
    /** Form preset values */
    static FormPresets: {
        addressPlaceholder: string;
    };
    /** Message displayed for unauthorized access */
    static unauthorizedMessage: string;
    /** Route for admin setup */
    static adminSetupRoute: string;
    /** Route for already opened resources */
    static alreadyOpenedRoute: string;
    /**
     * Secret key for encryption/authentication
     * @security This should be stored securely and not exposed in client-side code
     */
    static secretKey: string;
    /** Collection of subscriptions to be closed when navigating between routes */
    static subsToCloseOnRoute: Subscription[];
}

/**
 * Configuration object containing default validation messages for different validation types.
 *
 * Each validation type has an associated message template that can be used to display
 * error messages to users when validation fails. Some messages include placeholders
 * (e.g., {{maxLength}}, {{minLength}}) that can be replaced with actual values.
 *
 * @example
 * // Using a validation message
 * const errorMessage = configValidationMessages[EValidationType.maxlength].message
 *   .replace('{{maxLength}}', '10');
 *
 * @type {Object.<EValidationType, {message?: string}>}
 */
declare const configValidationMessages: {
    [x in EValidationType]: {
        message?: string;
    };
};

/**
 * Component that provides an "Add Item" button functionality.
 * This component can be used to add items to either a FormArray or a regular array.
 */
declare class AddItemComponent {
    /**
     * The text to display on the add button.
     * @default 'Add item'
     */
    addText: string;
    /**
     * The FormArray to which items will be added.
     * Use this when working with reactive forms.
     */
    formArray: FormArray;
    /**
     * The array to which items will be added.
     * Use this when working with regular arrays instead of FormArrays.
     */
    array: any[];
    /**
     * Event emitted when the add button is clicked.
     * The parent component should handle this event to add the item to the array.
     */
    clickedAdd: EventEmitter<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddItemComponent, "add-item", never, { "addText": { "alias": "addText"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "array": { "alias": "array"; "required": false; }; }, { "clickedAdd": "clickedAdd"; }, never, never, true, never>;
}

declare class PageLoaderService extends PageLoader {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageLoaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageLoaderService>;
}
/**
 * Service for managing loading states throughout the application.
 * Provides methods to start, stop, and track loading operations using tokens or named keys.
 */
declare class LoaderService {
    /** Internal signal storing named loader tokens as object keys */
    protected readonly _loaderKeyTokens: _angular_core.WritableSignal<{
        [key: string]: true;
    }>;
    /** Internal signal storing numeric loader tokens as an array */
    protected readonly _loaderTokens: _angular_core.WritableSignal<1[]>;
    /**
     * Combined list of all active loader tokens (both numeric and named)
     */
    readonly loaderTokens: _angular_core.Signal<(string | 1)[]>;
    /**
     * String representation of all active loader tokens, joined by commas
     */
    readonly loaderTokensString: _angular_core.Signal<string>;
    /**
     * Boolean signal indicating if any loader is currently active
     */
    readonly isLoading: _angular_core.Signal<boolean>;
    /**
     * Starts a loading operation
     * @param tokensToAdd Number of anonymous tokens to add (defaults to 1)
     */
    play(tokensToAdd?: number): void;
    /**
     * Starts a named loading operation
     * @param key Unique identifier for the loading operation
     */
    play(key: string): void;
    /**
     * Stops all loading operations and starts a new one
     * @returns The service instance for chaining
     */
    restart: () => void;
    /**
     * Stops a loading operation
     * @param tokensToAdd Number of anonymous tokens to remove (defaults to 1)
     */
    stop(tokensToAdd?: number): void;
    /**
     * Stops a named loading operation
     * @param key Unique identifier of the loading operation to stop
     */
    stop(key: string): void;
    /**
     * Stops all loading operations by clearing all tokens
     */
    fullStop: () => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoaderService>;
}

/**
 * Service for determining and managing page types within the application.
 * Provides utility methods to check the current page type against expected types.
 */
declare class PageService {
    /** Current page type */
    pageType: EPageType;
    constructor();
    /**
     * Compares the current page type with a preferred page type.
     * @param activatedRoute - The current activated route
     * @param overridePageType - Optional override for the page type
     * @param preferredPageType - The page type to compare against
     * @returns Boolean indicating if the current page type matches the preferred type
     */
    comparer: (activatedRoute: ActivatedRoute, overridePageType?: EPageType, preferredPageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a clone page.
     * @param activatedRoute - The current activated route
     * @param overridePageType - Optional override for the page type
     * @returns Boolean indicating if the current page is a clone page
     */
    isClone: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a create page.
     * @param activatedRoute - The current activated route
     * @param overridePageType - Optional override for the page type
     * @returns Boolean indicating if the current page is a create page
     */
    isCreate: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is an edit page.
     * @param activatedRoute - The current activated route
     * @param overridePageType - Optional override for the page type
     * @returns Boolean indicating if the current page is an edit page
     */
    isEdit: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is an index page.
     * @param activatedRoute - The current activated route
     * @param overridePageType - Optional override for the page type
     * @returns Boolean indicating if the current page is an index page
     */
    isIndex: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a show page.
     * @param activatedRoute - The current activated route
     * @param overridePageType - Optional override for the page type
     * @returns Boolean indicating if the current page is a show page
     */
    isShow: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageService>;
}

/**
 * Storage utility class that provides methods for saving, retrieving, and managing data
 * in browser storage (localStorage or sessionStorage) with optional encryption.
 */
declare class StorageClass {
    /**
     * Gets the secret key used for encryption from Config
     * @returns The secret key string
     */
    get secret(): string;
    private storageKey;
    /**
     * Indicates whether the application is running in production mode
     * @returns Boolean value from environment.production
     */
    get isProduction(): boolean;
    /**
     * Initializes a new instance of StorageClass
     * Sets the storage type based on environment configuration
     */
    constructor();
    /**
     * Switches storage to use sessionStorage
     */
    useSession(): void;
    /**
     * Switches storage to use localStorage
     */
    useLocal(): void;
    /**
     * Encrypts data using AES encryption
     * @param data - The data to encrypt
     * @param key - The encryption key (defaults to secret key)
     * @returns Encrypted string
     */
    encrypt: (data: any, key?: string) => any;
    /**
     * Decrypts encrypted data
     * @param data - The encrypted data to decrypt
     * @param key - The decryption key (defaults to secret key)
     * @returns Decrypted data object
     */
    decrypt: (data: any, key?: string) => any;
    /**
     * Saves data to storage with optional encryption in production
     * @param key - The key to store the data under
     * @param data - The data to store
     * @returns The stored data or null if operation failed
     */
    saveItem: <T>(key: string, data: T) => any;
    /**
     * Saves data to storage asynchronously with Promise interface
     * @param key - The key to store the data under
     * @param data - The data to store
     * @returns Promise resolving to the stored data
     */
    saveItemA: <T>(key: string, data: T) => Promise<T>;
    /**
     * Saves data to storage asynchronously with Observable interface
     * @param key - The key to store the data under
     * @param data - The data to store
     * @returns Observable emitting the stored data
     */
    saveItem$: <T = any>(key: string, data: T) => Observable<T>;
    /**
     * Retrieves data from storage with optional decryption in production
     * @param key - The key of the item to retrieve
     * @param _throw - Whether to throw an error if item not found
     * @returns The retrieved data or null if not found
     */
    getItem: <T = any>(key: string, _throw?: boolean) => T;
    /**
     * Get an item from storage asynchronously
     * @param key Name of item
     * @returns
     */
    getItemA: <T = any>(key: string) => Promise<T>;
    /**
     * Get an item from storage asynchronously
     * @param key Name of item
     * @returns
     */
    getItem$: <T = any>(key: string) => Observable<T>;
    /**
     * Removes an item from storage
     * @param key - Name of item to remove
     * @returns Result of the removal operation
     */
    removeItem: (key: string) => void;
    /**
     * Removes an item from storage asynchronously with Observable interface
     * @param key - Name of item to remove
     * @returns Observable emitting the result of the removal operation
     */
    removeItem$: (key: string) => Observable<unknown>;
    /**
     * Clears all items from storage with optional exclusion list
     * @param exclusionList - Optional list of keys to preserve during clear operation
     */
    clear: (exclusionList?: string[]) => void;
}
/**
 * Injectable service that extends StorageClass to provide storage functionality
 * throughout the application. Available as a singleton through Angular's DI system.
 */
declare class ETSStorageService extends StorageClass {
    /**
     * Initializes a new instance of ETSStorageService
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSStorageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSStorageService>;
}

/** HTTP methods supported by the logger */
type Method = 'POST' | 'PUT';
/**
 * Interface for log entry data
 * @template T Type of the payload data
 */
interface ILog<T> {
    /** The data payload to be logged */
    payload: T;
    /** Optional array of file data */
    files?: Partial<File>[];
    /** Indicates if the request was successful */
    isSuccess?: boolean;
    /** The route path */
    route?: string;
    /** The API endpoint */
    endpoint: string;
    /** The HTTP method used */
    method: Method;
    /** Flag indicating if the request payload was too large */
    reqPayloadTooLarge?: boolean;
    /** Flag indicating if the response payload was too large */
    resPayloadTooLarge?: boolean;
}
/**
 * Log class that implements the ILog interface
 * @template T Type of the payload data, defaults to any
 */
declare class Log<T = any> implements ILog<T> {
    /** Unique identifier for the log entry */
    id: string;
    /** Title of the log entry */
    title: string;
    /** Timestamp when the log was created */
    time: number;
    /** The data payload */
    payload: T;
    /** Indicates if the request was successful */
    isSuccess: boolean;
    /** The route path */
    route: string;
    /** The API endpoint */
    endpoint: string;
    /** Array of file data */
    files: IFileData[];
    /** The HTTP method used */
    method: Method;
    /** Error information if request failed */
    error: any;
    /** Response data from the request */
    response: any;
    /** Flag indicating if the request payload was too large */
    reqPayloadTooLarge?: boolean;
    /** Flag indicating if the response payload was too large */
    resPayloadTooLarge?: boolean;
    /**
     * Creates a new Log instance
     * @param data The log data conforming to ILog interface
     */
    constructor(data: ILog<T>);
}
/**
 * Interface for file metadata
 */
interface IFileData {
    /** Name of the file */
    title: string;
    /** Size of the file in bytes */
    size: number;
    /** MIME type of the file */
    type: string;
}

declare class ObjectSizeService {
    /**
     * Returns the size in bytes
     * @param object
     * @returns
     */
    roughSizeOfObject: (object: any, maxSize?: number) => {
        bytes?: number;
        crossedMaxSize?: boolean;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectSizeService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ObjectSizeService>;
}

/**
 * Service for logging application events and errors with size-limited payloads
 * Provides authentication for accessing logs and persistent storage
 */
declare class LoggerService {
    sS: ETSStorageService;
    /** Storage key for log authentication */
    readonly logAuthKey = "logAuth";
    /** Storage key for logs */
    readonly logsKey = "logs";
    /** Signal containing logs loaded from storage */
    protected readonly _storageLogs: _angular_core.WritableSignal<Log<any>[]>;
    /** Signal containing newly added logs */
    protected readonly _newLogs: _angular_core.WritableSignal<Log<any>[]>;
    /** Combined unique logs from storage and new logs */
    readonly logs: _angular_core.Signal<Log<any>[]>;
    /** Authentication state signal */
    protected readonly _isAuthed: _angular_core.WritableSignal<boolean>;
    /** Maximum number of logs to keep */
    protected maxLength: number;
    /** Password for log authentication */
    readonly pwd = "1234";
    /** Service for calculating object sizes */
    objectSizeService: ObjectSizeService;
    /** Maximum payload size in KB */
    readonly maxPayloadSize = 15;
    /** Maximum payload size in bytes */
    protected readonly maxPayloadSizeBytes: number;
    /**
     * Creates an instance of LoggerService
     * @param sS - Storage service for persisting logs
     */
    constructor(sS: ETSStorageService);
    /**
     * Adds a new log entry
     * @param log - Log data to be added
     * @typeParam T - Type of the log payload
     */
    addLog<T>(log: ILog<T>): void;
    /**
     * Adds a log to the collection and trims payloads if they exceed size limits
     * @param log - Log object to be added
     */
    pushLog(log: Log): void;
    /**
     * Saves logs to local storage, limiting to the maximum number of logs
     */
    saveToLocal(): void;
    /**
     * Authenticates the logger by saving the password to storage
     */
    unlock(): void;
    /**
     * Removes authentication by clearing the password from storage
     */
    lock(): void;
    /**
     * Retrieves logs from storage and updates the storage logs signal
     * @returns Promise that resolves when logs are loaded
     */
    getLogs(): Promise<void>;
    /**
     * Verifies if the logger is authenticated by checking storage
     */
    checkAuth(): void;
    /**
     * Logs the current state of the logger (commented out in production)
     * @param title - Title for the log state output
     */
    protected logState(title: string): void;
    /**
     * Computed property that returns the current authentication state
     */
    isAuthed: _angular_core.Signal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoggerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoggerService>;
}

/**
 * Service for debouncing function calls to prevent excessive executions
 * when triggered multiple times in quick succession.
 */
declare class DebouncerService {
    /**
     * Holds the keys for debouncing with their associated callbacks
     */
    debounceKeys: {
        [key: string]: {
            callback: () => any;
        };
    };
    /**
     * Subject that emits when a debounced function should be executed
     */
    listener: BehaviorSubject<boolean>;
    /**
     * Flag to track if the listener subscription is active
     */
    isListening: boolean;
    constructor();
    /**
     * Initializes the debounce listener if not already listening
     * Sets up subscription to execute callbacks after debounce period
     * @private
     */
    private startListener;
    /**
     * Wrapper function that facilitates debouncing of function calls
     * @param config Configuration object for the debouncer
     * @param config.uniqueKey Identifier for the function to debounce
     * @param config.callback Function to call after debouncing
     */
    debouncer: (config: {
        uniqueKey: string;
        callback: () => any;
    }) => void;
    /**
     * Counter used for debugging async validations
     * @private
     */
    counter: number;
    /**
     * Asynchronous validator wrapper built on top of the debouncer function
     * Specifically tuned for Angular AbstractControl async validators
     *
     * @param config Configuration object for the async validation
     * @param config.uniqueKey Identifier for the validation function
     * @param config.callback Async function to call after debouncing that returns validation result
     * @param config.validationError Optional custom validation error to return on failure
     * @returns Promise that resolves to a CustomValidationError or null if valid
     */
    asyncValidation: <TData extends {
        response?: boolean;
    } = any>(config: {
        uniqueKey: string;
        callback: () => Promise<TData>;
        validationError?: CustomValidationError;
    }) => Promise<CustomValidationError>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DebouncerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DebouncerService>;
}

/**
 * Interface for dialog button configuration
 * Extends the base button interface with dialog-specific properties
 */
interface IInfoDialogBtn extends IBtn {
    /**
     * Determine whether to close the info on clicking the button
     */
    closeBoxOnClick?: boolean;
}

/**
 * Service for handling and reporting errors to Sentry.
 * Provides methods for error tracking, user identification, and message reporting.
 */
declare class ErrorReporterService {
    protected readonly errorHandler: Sentry.SentryErrorHandler;
    /**
     * Creates Sentry browser options configuration
     * @param env - SDK environment configuration
     * @param baseURLs - List of base URLs to include in trace propagation targets
     * @returns Sentry browser configuration options
     */
    static sentryOptions: (env: SDKEnvironment, baseURLs: string[]) => Sentry.BrowserOptions;
    /**
     * Provides the necessary Angular providers for Sentry integration
     * @returns Array of providers for Sentry services
     */
    static sentryProviderOptions: () => (Provider | EnvironmentProviders)[];
    constructor();
    /**
     * Checks if error reporting is enabled in the current environment
     * @returns void or undefined if reporting is disabled
     */
    protected checkIfShouldReport: () => void;
    /**
     * Sets the current user information for error context
     * @param user - Object containing user information
     * @param user.fullName - Full name of the user
     * @param user.email - Email address of the user
     */
    setCurrentUser(user: {
        fullName: string;
        email: string;
    }): void;
    /**
     * Handles an error using Sentry's error handler
     * @param error - The error to be handled
     */
    handleError(error: any): void;
    /**
     * Reports an exception to Sentry
     * @param error - The error to be reported
     */
    reportError(error: any): void;
    /**
     * Reports a message to Sentry
     * @param message - The message to be reported
     */
    reportMessage(message: string | undefined | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorReporterService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ErrorReporterService>;
}

declare class NumberFormatService {
    readonly numberFormat: _angular_core.WritableSignal<"AM" | "EU">;
    readonly isNormal: _angular_core.Signal<boolean>;
    readonly locale: _angular_core.Signal<"en-US" | "fr-FR">;
    readonly decimal: _angular_core.Signal<"." | ",">;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberFormatService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NumberFormatService>;
}

/**
 * A comprehensive utility service that provides various helper functions and services for Angular applications.
 * This service includes functionality for form handling, date formatting, file operations, and more.
 *
 * @template TEnvironment - The type of environment configuration to use, defaults to SDKEnvironment
 */
declare class UtilityService<TEnvironment extends SDKEnvironment = SDKEnvironment> {
    /** Angular Material Dialog service for managing dialogs */
    readonly dialog: MatDialog;
    /** Angular Material SnackBar service for displaying notifications */
    readonly snackBar: MatSnackBar;
    /** Angular Router service for navigation */
    readonly router: Router;
    /** Angular Title service for managing page titles */
    readonly titleS: Title;
    /** Angular Location service for browser location management */
    readonly location: Location;
    /** Service for managing page loading states */
    readonly pS: PageLoaderService;
    /** Angular CurrencyPipe for currency formatting */
    readonly currencyPipe: CurrencyPipe;
    /** Angular TitleCasePipe for text case transformation */
    readonly titleCasePipe: TitleCasePipe;
    /** Service for logging operations */
    readonly loggerService: LoggerService;
    /** Service for error reporting */
    readonly errorReporterService: ErrorReporterService;
    /** Service for page-related operations */
    readonly pageS: PageService;
    /** Service for responsive design breakpoint observation */
    readonly responsive: BreakpointObserver;
    /** Angular DatePipe for date formatting */
    readonly datePipe: DatePipe;
    /** Service for number formatting operations */
    readonly numberFormatService: NumberFormatService;
    /** Service for debouncing operations */
    readonly debouncerService: DebouncerService;
    /** Angular DecimalPipe for decimal number formatting */
    readonly numberPipe: DecimalPipe;
    /** Service for calculating object sizes */
    readonly objectSizeService: ObjectSizeService;
    /** Service for toast notifications */
    readonly toastNotificationService: ToastNotificationsService;
    /** Base route configuration */
    r: AppRouteBase;
    /** File downloader utility using js-file-download */
    downloader: typeof jfd;
    /** Enum for validation types */
    eValidationType: typeof EValidationType;
    /** Application configuration */
    config: typeof Config;
    /** Current environment configuration */
    environment: TEnvironment;
    /** Enum for page button IDs */
    pbid: typeof EETSPageBtnID;
    /** jQuery reference */
    $: any;
    /** Flag indicating if the current device is mobile */
    isMobile: boolean;
    /** Emits true if the device is mobile */
    mobileQueryChanged: ReplaySubject<boolean>;
    /** Signal that emits true when the device is a mobile handset */
    readonly isMobileSignal: _angular_core.Signal<boolean>;
    /** Signal that emits true when the device is a tablet */
    readonly isTabletSignal: _angular_core.Signal<boolean>;
    /** Signal that emits true when the device is a desktop */
    readonly isDesktopSignal: _angular_core.Signal<boolean>;
    /** Available options for page size in paginated views */
    pageSizeOptions: number[];
    /** Date pipe format for full date display */
    datePipeDate: string;
    /** Date pipe format for compact date display */
    datePipeDateLean: string;
    /** Date pipe format for compact date and time display */
    datePipeDateTimeLean: string;
    /** Field name used for custom ID tracking */
    readonly customIDField = "__id";
    /** Delimiter used for string operations */
    readonly delimiter = "~~~//~~~";
    /** Non-nullable form builder instance */
    formBuilder: _angular_forms.NonNullableFormBuilder;
    constructor();
    /**
     * Creates a form control configuration array for use with FormBuilder
     * @param value - Initial value for the control
     * @param validatorOrOpts - Validators or options for the control
     * @param asyncValidator - Async validators for the control
     * @returns Array containing value, validators, and async validators
     * @template T - Type of the form control value
     */
    formControl: <T>(value?: T | null, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[]) => (AsyncValidatorFn | AsyncValidatorFn[] | ValidatorFn | ValidatorFn[] | T | FormControlOptions)[];
    /**
     * Navigates back to the previous page using Angular's Location service
     */
    back: () => void;
    /**
     * Shortcut for toast notifications
     */
    readonly toast: {
        add: (item: _serene_dev_toast_notifications.IAddToastNotification) => {
            id: string;
            update: (update: Partial<_serene_dev_toast_notifications.IAddToastNotification>) => void;
            close: () => void;
            loader: {
                play: () => void;
                stop: () => void;
            };
            closed: rxjs.Subject<{
                manuallyClosed: boolean;
            }>;
        };
        close: (id: string, manualDismissal: boolean) => void;
        update: (id: string, item: Partial<_serene_dev_toast_notifications.IAddToastNotification>) => void;
    };
    /**
     * Utility to calculate approximate size of an object
     */
    readonly roughSizeOfObject: (object: any, maxSize?: number) => {
        bytes?: number;
        crossedMaxSize?: boolean;
    };
    /**
     * Ensures only one input from a group can be active at a time.
     * When one input has a value, all others are disabled.
     * @param inputs - Array of form controls to manage
     * @returns Subscription that can be used to unsubscribe from the input changes
     * @example
     * // Create form controls
     * const nameControl = new FormControl('');
     * const idControl = new FormControl('');
     * const emailControl = new FormControl('');
     *
     * // Make them mutually exclusive
     * const subscription = utilityService.onlyOneInput([nameControl, idControl, emailControl]);
     *
     * // Later, unsubscribe when done
     * subscription.unsubscribe();
     */
    onlyOneInput(inputs: FormControl[]): Subscription;
    formatCode: (map: {
        [code: string]: Partial<ICodeTitle & ICodeDescription>;
    }) => (code: string | undefined | null) => string;
    /**
     * Copies a payload to clipboard in debug mode
     * @param payload - Data to be copied to clipboard
     * @example
     * // Copy API response to clipboard in debug mode
     * utilityService.copyPayload(apiResponse);
     */
    copyPayload(payload: any): Promise<void>;
    /**
     * Returns the value x if it's not null or undefined, otherwise returns y
     * @param x - Primary value to return if not null/undefined
     * @param y - Default value to return if x is null/undefined (defaults to '-')
     * @returns x if not null/undefined, otherwise y
     * @example
     * // Returns "User" since the value exists
     * utilityService.xOrY("User", "Guest"); // "User"
     *
     * // Returns "-" (default fallback) since value is null
     * utilityService.xOrY(null); // "-"
     *
     * // Returns "N/A" (custom fallback) since value is undefined
     * utilityService.xOrY(undefined, "N/A"); // "N/A"
     */
    xOrY: (x: any, y?: string) => string;
    /**
     * Converts text to title case using Angular's TitleCasePipe
     * @param text - Text to convert to title case
     * @returns Text in title case format
     * @example
     * utilityService.toTitleCase("hello world"); // "Hello World"
     * utilityService.toTitleCase("USER_PROFILE"); // "User Profile"
     */
    toTitleCase(text: string): string;
    /**
     * Convert Date string to Date Time string
     * @param dateStr - Date string
     * @param config - Configuration for the conversion
     * @returns Returns a Date Time string
     * @example
     * // Basic conversion with default time (00:00:00Z)
     * utilityService.dateToDateTime('2022-01-25'); // '2022-01-25T00:00:00Z'
     *
     * // With custom time
     * utilityService.dateToDateTime('2022-01-25', { time: '14:30:00Z' }); // '2022-01-25T14:30:00Z'
     *
     * // Without T separator
     * utilityService.dateToDateTime('2022-01-25', { omitT: true }); // '2022-01-25 00:00:00'
     */
    dateToDateTime: (dateStr: string, config?: {
        /**
         * Use the yyyy-mm-dd hh:mm:ss format
         */
        omitT?: boolean;
        /**Time to append to date. @example `12:00:00Z` */
        time?: string;
    }) => string;
    /**
     * Set an Object's field if the object exists or don't if the object doesn't
     * @param obj - Object holding the field
     * @param kvps - Partial<T> object containing the field and its value
     * @returns Returns the object holding the data
     * @example
     * const user = { name: 'John', age: 30 };
     *
     * // Update user's age and add a new field
     * utilityService.setterWithNull(user, { age: 31, role: 'Admin' });
     * // user is now { name: 'John', age: 31, role: 'Admin' }
     *
     * // Returns null if object is null
     * utilityService.setterWithNull(null, { name: 'Test' }); // null
     */
    setterWithNull<T>(obj: T, kvps: Partial<T>): T;
    /**
     * (Set an Object's field if the object exists or don't if the object doesn't) for multiple entries
     * @param items - Array of objects and their modifications
     */
    setterWithNullArray<T>(items: {
        obj: T;
        kvps: Partial<T>;
    }[]): void;
    /**
     * Handles the deletion of rows from a FormArray
     * @param index - Index of the row to delete
     * @param fa - The FormArray that holds the rows
     * @param deleteService - The deletion service to be called (It should be an anonymous function)
     * @param addRowFunc - The function (anonymous) that adds a new row to the FormArray
     * @param extraConfig - Optional configuration for the deletion operation
     * @returns Promise that resolves after deletion is complete
     * @example
     * // Delete a row from a form array of addresses
     * const deleteAddress = (id) => this.apiService.deleteAddress(id);
     * const addNewAddress = () => this.addressesFormArray.push(this.createAddressFormGroup());
     *
     * utilityService.handleFormRowDelete(
     *   2, // Delete the third row (index 2)
     *   this.addressesFormArray,
     *   deleteAddress,
     *   addNewAddress,
     *   {
     *     dontEmitEvent: true,
     *     onDelete: (response) => console.log('Address deleted', response)
     *   }
     * );
     */
    handleFormRowDelete: (index: number, fa: UntypedFormArray, deleteService: (...args: any) => Promise<any> | Observable<any>, addRowFunc: (...args: any) => any, extraConfig?: {
        dontEmitEvent?: boolean;
        onDelete?: (res: any) => any;
    }) => Promise<any>;
    /**
     * Opens an HTML element in fullscreen mode
     * @param elem - HTML element to display in fullscreen
     * @param metadata - Optional metadata to pass to the onLeave callback
     * @param onLeave - Optional callback function when leaving fullscreen mode
     * @example
     * // Open an image viewer in fullscreen
     * const imageViewer = document.getElementById('image-viewer');
     * const imageData = { id: '123', url: 'https://example.com/image.jpg' };
     *
     * utilityService.openHTMLInFullscreen(
     *   imageViewer,
     *   imageData,
     *   (data) => console.log('Left fullscreen view of image:', data.id)
     * );
     */
    openHTMLInFullscreen<TMetadata>(elem: HTMLElement, metadata?: TMetadata, onLeave?: (metadata: TMetadata) => any): void;
    /**
     * Exits fullscreen mode
     * @example
     * // Exit fullscreen when a button is clicked
     * closeButton.addEventListener('click', () => {
     *   utilityService.closeFullscreen();
     * });
     */
    closeFullscreen(): void;
    /**
     * Adds subscriptions to be automatically closed when navigating away
     * @param sub - Subscriptions to be closed
     * @example
     * const dataSub = this.dataService.getData().subscribe(data => this.data = data);
     * const statusSub = this.statusService.getStatus().subscribe(status => this.status = status);
     *
     * // These subscriptions will be automatically unsubscribed when navigating to another route
     * this.utilityService.addToSubsToCloseOnRoute(dataSub, statusSub);
     */
    addToSubsToCloseOnRoute: (...sub: Subscription[]) => void;
    /**
     * Clears all subscriptions that were added to be closed on route change
     */
    clearSubsToCloseOnRoute: () => void;
    /**
     * Handles the deletion of rows from an array
     * @param index - Index of the row to delete
     * @param arr - The array that holds the rows
     * @param deleteService - The deletion service to be called (It should be an anonymous function)
     * @param addRowFunc - The function (anonymous) that adds a new row to the array
     * @param cb - The function to callback with the response of the deletion service as the input parameter
     */
    handleRowDelete: <T>(index: number, arr: any[], deleteService: (...args: any) => Promise<T> | Observable<T>, addRowFunc: (...args: any) => any, cb?: (any: any) => any) => Promise<void>;
    /**
     * To handle the patching of a FormArray
     * @param arr - The array that contains the data
     * @param addFunc - The function that performs addition of single entries
     * @param formArr - The FormArray that will hold the array's data
     */
    initPatchFormArray: <T>(arr: T[], addFunc: (i: number, data?: T, formArr?: FormArray) => void, formArr: FormArray) => void;
    /**
     * Checks if a value is a Promise
     * @param func - Value to check
     * @returns True if the value is a Promise
     */
    private isPromise;
    /**
     * Checks if a function is async
     * @param func - Function to check
     * @returns True if the function is async
     */
    isAsync: (func: any) => boolean;
    /**
     * Checks if a value is an Observable
     * @param func - Value to check
     * @returns True if the value is an Observable
     */
    isObservable: <T>(func: any) => func is Observable<unknown>;
    /**
     * Converts a value to a Promise
     * @param val - Value to convert
     * @returns Promise that resolves with the value
     */
    promisifyVal: <T>(val: T | Promise<T> | Observable<T>) => Promise<Awaited<T>>;
    getCodeTitles: <T>(obs: Observable<T[]>, valueField: keyof T) => Observable<{
        list: T[];
        map: {
            [x: string]: T;
        };
    }>;
    rxResourceErrorWrapper: <T>(obs: Observable<T>) => Observable<T>;
    resourceErrorWrapper: <T>(ps: Promise<T>) => Promise<any>;
    /**
     * Merges multiple observables into a single observable
     * @param arr - Array of observables to fetch
     * @returns An array of the responses merged together. It emits the merged responses as they are fetched and closes once all the responses have been fetched
     */
    mergeArrObservables: <T>(arr: {
        $func: Observable<T[]>;
    }[]) => Observable<T[]>;
    /**
     * Removes duplicate items from an array based on a key field
     * @param list - Array to remove duplicates from
     * @param keyField - Field to use for comparison (defaults to 'code')
     * @returns Array with duplicates removed
     */
    removeDuplicate<T>(list: T[], keyField?: string): T[];
    /**
     * Generates a random ID
     */
    get genRandomID(): number;
    /**
     * Picks a random item from an array
     * @param array - Array to pick from
     * @returns Random item or null if array is empty
     */
    pickRandomIndex: <T>(array: T[]) => T | null;
    /**
     * Stores a payload in the logger
     */
    storePayload: <T>(log: ets_fe_ng_sdk.ILog<T>) => void;
    /**
     * Checks if an object is empty, optionally excluding certain fields
     * @param obj - Object to check
     * @param exclusionFields - Fields to exclude from the check
     * @returns True if the object is empty
     */
    objIsEmpty: (obj: any, exclusionFields?: string[]) => boolean;
    /**
     * Generates an array of objects with random string values for the specified keys.
     * @param keys - Array of keys to include in each object.
     * @param length - Number of objects to generate (default is 10).
     * @returns An array of objects with random string values.
     * @example
     * utilityService.dataGen(['name', 'email'], 2);
     * // [{ name: 'random123', email: 'random456' }, { name: 'random789', email: 'random101' }]
     */
    dataGen: <T = any>(keys: string[], length?: number) => T[];
    /**
     * Generates a random string value.
     * @returns A random string in the format 'randomXXX'.
     * @example
     * utilityService.textGen(); // 'random123'
     */
    textGen: () => string;
    /**
     * TrackBy function for Angular lists using the 'code' property.
     * @param index - Index of the item.
     * @param item - The item object.
     * @returns The 'code' property of the item.
     * @example
     * <div *ngFor="let item of items; trackBy: utilityService.trackByCode">...</div>
     */
    trackByCode(index: number, item: any): any;
    /**
     * TrackBy function for Angular lists using the 'id' property.
     * @param index - Index of the item.
     * @param item - The item object.
     * @returns The 'id' property of the item.
     * @example
     * <div *ngFor="let item of items; trackBy: utilityService.trackByID">...</div>
     */
    trackByID(index: number, item: any): any;
    /**
     * Opens a dialog and handles the result with provided callbacks.
     * @param comp - The component to open in the dialog.
     * @param config - Dialog configuration.
     * @param valueCB - Callback if a value is returned.
     * @param noValueCB - Optional callback if no value is returned.
     * @example
     * utilityService.dialogOpener(MyDialogComponent, config, (result) => { ... });
     */
    dialogOpener: (comp: any, config: MatDialogConfig, valueCB: (r: any) => any, noValueCB?: any) => Subscription;
    /**
     * Opens a dialog and returns the dialog reference.
     * @param comp - The component to open in the dialog.
     * @param config - Dialog configuration.
     * @returns The MatDialogRef instance.
     * @example
     * const ref = utilityService.dialogOpenerRef(MyDialogComponent, config);
     */
    dialogOpenerRef: (comp: any, config: MatDialogConfig) => _angular_material_dialog.MatDialogRef<unknown, any>;
    /**
     * Finds and formats a label for an item from an array, using a key and label field.
     * @param item - The item value to find.
     * @param arr - The array to search.
     * @param labelField - The field to use for the label (default: 'title' or 'description').
     * @param keyField - The field to use as the key (default: 'code').
     * @returns A formatted string combining the item and its label, or the item if not found.
     * @example
     * utilityService.findLabelByItem('A1', [{ code: 'A1', title: 'Alpha' }]); // 'A1 - Alpha'
     */
    findLabelByItem: (item: any, arr: any[], labelField?: string, keyField?: string) => any;
    go: (value: string, extra?: NavigationExtras) => void;
    /**
     * Route to component
     * @param route Route of path to component
     * @param extra
     */
    goR: (route: string, extra?: NavigationExtras) => void;
    /**
     * Provides a set of router utilities for relative navigation and parameter access.
     * @returns An object containing the current route, router, navigation function, query params, and path params.
     * @example
     * const { navigate, queryParams, pathParams } = utilityService.relativeRouter();
     * navigate('details', { queryParams: { id: 1 } });
     */
    relativeRouter(): {
        route: ActivatedRoute;
        router: Router;
        navigate: (link: string, config?: NavigationExtras | undefined) => Promise<boolean>;
        queryParams: i1.Params;
        pathParams: i1.Params;
    };
    /**
     * Formats a number as currency using the current locale.
     * @param amount - The amount to format.
     * @param currency - The currency code (default is a space for generic formatting).
     * @returns The formatted currency string.
     * @example
     * utilityService.moneyParser(1000, 'USD'); // "$1,000.00"
     */
    moneyParser: (amount: string | number, currency?: string) => string;
    /**
     * Extracts uploaded files from an input event.
     * @param event - The file input event.
     * @returns An array of uploaded files, or an empty array if none found.
     * @example
     * const files = utilityService.extractUpload($event);
     */
    extractUpload(event: any): File[];
    /**
     * Converts seconds to an object containing hours, minutes, and seconds.
     * @param seconds - The total number of seconds.
     * @returns An object with hours, mins, and secs properties.
     * @example
     * utilityService.secondsToHourMinSec(3661); // { hours: 1, mins: 1, secs: 1 }
     */
    secondsToHourMinSec: (seconds: number) => {
        hours: number;
        mins: number;
        secs: number;
    };
    /**
     * Converts minutes to an object containing days, hours, and minutes.
     * @param minutes - The total number of minutes.
     * @returns An object with days, hours, and mins properties.
     * @example
     * utilityService.minutesToDayHourMin(1500); // { days: 1, hours: 1, mins: 0 }
     */
    minutesToDayHourMin: (minutes: number) => {
        days: number;
        hours: number;
        mins: number;
    };
    /**
     * Converts minutes to a string in the format "D H:M".
     * @param minutes - The total number of minutes.
     * @returns A formatted string or null if input is falsy.
     * @example
     * utilityService.minutesToDayHourMinStr(1500); // "1 1:0"
     */
    minutesToDayHourMinStr: (minutes: number) => string;
    /**
     * Converts minutes to a string in the format "Ddays Hhrs Mmins".
     * @param minutes - The total number of minutes.
     * @returns A formatted string or null if input is falsy.
     * @example
     * utilityService.minutesToDayHourMinStr2(1500); // "1days 1hrs 0mins"
     */
    minutesToDayHourMinStr2: (minutes: number) => string;
    /**
     * Converts days, hours, and minutes to a string in the format "HH:MM".
     * @param dys - Number of days.
     * @param hrs - Number of hours.
     * @param mins - Number of minutes.
     * @returns A string in the format "HH:MM" or an empty string if all inputs are falsy.
     * @example
     * utilityService.dayHourMinToHourMinutes(1, 2, 30); // "26:30"
     */
    dayHourMinToHourMinutes: (dys: number, hrs: number, mins: number) => string;
    /**
     * Enables or disables a collection of form controls
     * @param controls Array of AbstractControls to enable or disable
     * @param disable Whether to disable (true) or enable (false) the controls
     */
    disableOrEnableInputs: (controls: AbstractControl[], disable: boolean) => void;
    /**
     * Disables a collection of form controls
     * @param controls Array of AbstractControls to disable
     */
    disableInputs: (controls: AbstractControl[]) => void;
    /**
     * Enables a collection of form controls
     * @param controls Array of AbstractControls to enable
     */
    enableInputs: (controls: AbstractControl[]) => void;
    /**
     * Converts days, hours, and minutes to total minutes
     * @param dys Number of days
     * @param hrs Number of hours
     * @param mins Number of minutes
     * @returns Total minutes or 0 if all inputs are falsy
     */
    dayHourMinToMinutes: (dys: number, hrs: number, mins: number) => number;
    /**
     * Converts hours and minutes to total minutes
     * @param hrs Number of hours
     * @param mins Number of minutes
     * @returns Total minutes or null if both inputs are falsy
     */
    hourMinToMinutes: (hrs: number, mins: number) => number;
    /**
     * Converts a time string in format "HH:MM" to total minutes
     * @param hrsMins Time string in format "HH:MM"
     * @returns Total minutes
     */
    hourMinToMinutes2: (hrsMins: string) => number;
    /**
     * Displays a notification message
     * @param message Message to display
     * @param cls Notification type: 0=error, 1=success, 2=info, 3=warning
     * @param duration Duration in milliseconds
     * @param title Optional title for the notification
     * @returns Object with closed observable
     * @example
     * // Success notification
     * utilityService.notify('Profile updated successfully', 1);
     *
     * // Error notification with custom duration
     * utilityService.notify('Failed to save changes', 0, 10000);
     *
     * // Info notification with title
     * utilityService.notify('Your session will expire in 5 minutes', 2, 5000, 'Session Expiry');
     */
    notify(message: string, cls?: 0 | 1 | 2 | 3, duration?: number, title?: string): {
        closed: rxjs.Subject<{
            manuallyClosed: boolean;
        }>;
    };
    /**
     * Scrolls the window to the top
     */
    scrollToTop: () => void;
    /**
     * Gets the current date and time in a format suitable for datetime-local inputs
     * @returns Current datetime in ISO format without timezone
     */
    getLocalDateTimeNow: () => string;
    /** @returns The current date local that can be used to set the date input */
    localDateNow: () => string;
    /**
     * Formats a date in various formats
     * @param date Date to format
     * @param format Format option: 1=toDateString, 2=DD Month, 3=EEE MMM DD YYYY, hh:mm aa, 4=Month DD
     * @returns Formatted date string or null if date is falsy
     */
    dateFormat: (date: any, format?: number) => string;
    /**
     * Converts an ISO date string to Java date string format
     * @param isoDateString ISO date string, defaults to current date
     * @returns Date string in Java format or null if input is falsy
     */
    toJavaDateString: (isoDateString?: string) => string;
    /**
     * Converts a date string to Java datetime format
     * @param isoDateString Date string to convert
     * @returns Datetime string in Java format or null if input is falsy
     */
    toJavaDatetimeString: (isoDateString: string) => string;
    /**
     * Formats a time string by removing seconds
     * @param time Time string to format
     * @returns Formatted time string
     */
    timeFormat: (time?: any) => string;
    /**
     * Formats a timestamp as a full date and time
     * @param timestamp Timestamp to format
     * @returns Formatted date and time string
     */
    fullDateTime: (timestamp: string | number) => string;
    /**
     * Formats a number of days into years, months, and days
     * @param days Number of days to format
     * @returns Formatted string or "-" if days is falsy
     */
    daysFormatter: (days: number) => string;
    /**
     * Formats a number of months into years and months
     * @param months Number of months to format
     * @returns Formatted string or "-" if months is falsy
     */
    monthsFormatter: (months: number) => string;
    /**
     * Adds appropriate plural suffix to a value
     * @param val Numeric value
     * @param txt Singular text
     * @param plural Optional plural text (defaults to txt + 's')
     * @returns Formatted string with value and appropriate suffix
     */
    pluarlizer: (val: number, txt: string, plural?: string) => string;
    /**
     * Converts a decimal to percentage string
     * @param dec Decimal value to convert
     * @returns Percentage string
     */
    decimalToPercentage: (dec: number) => string;
    /**
     * Logs form details to console
     * @param form Form to log
     */
    logForm: (form: any) => void;
    /**
     * Converts data to CSV and triggers download
     * @param data Array of data objects
     * @param headerNames Array of header names
     * @param filename Filename for the downloaded file
     */
    toCSV(data: any[], headerNames: string[], filename: string): void;
    /**
     * Checks if a filename has a picture format extension
     * @param fileName Filename to check
     * @returns True if filename has a picture format extension
     */
    isPictureFormat(fileName: string): boolean;
    /**
     * Converts an object to an array of its values
     * @param obj Object to convert
     * @returns Array of object values
     */
    objectToArray<T>(obj: any): T[];
    /**
     * Formats a field name to title case
     * @param field Field name to format
     * @returns Formatted field name
     */
    formatField(field: string): string;
    /**
     * Uses a web worker to perform a task
     * @param worker Web worker object
     * @param inputData Data to pass to the web worker
     * @param conditions Optional conditions for stopping or error handling
     * @returns Observable of worker results
     */
    useWebWorker<T = any>(worker: Worker, inputData: any, conditions?: {
        stop: (res: any) => boolean;
        error: (res: any) => boolean;
    }): Observable<T>;
    /**
     * Creates a function that trims text to a specified length
     * @param length Maximum length before trimming
     * @returns Function that trims text
     */
    trim: (length?: number) => (text: string | undefined) => string;
    /**
     * Converts an array to CSV and triggers download
     * @param data Array of data objects
     * @param filename Filename for the downloaded file
     * @param headerMap Optional column definitions
     * @param extraConfig Optional configuration
     */
    arrayToCSV(data: any[], filename: string, headerMap?: TableCol[], extraConfig?: {
        prefix?: string;
        hideHeader?: boolean;
        hideNotification?: boolean;
    }): Promise<void>;
    /**
     * Type casting helper
     * @param value Value to cast
     * @returns The same value with type information
     */
    typeCaster: <T>(value: T) => T;
    /**
     * Joins multiple CSV strings with newlines
     * @param CSVs CSV strings to join
     * @returns Combined CSV string
     */
    joinCSVRows(...CSVs: string[]): string;
    /**
     * Converts an array to a CSV string
     * @param data Array of data objects
     * @param headerMap Optional column definitions
     * @param extraConfig Optional configuration
     * @returns CSV string
     */
    arrayToCSVString<T = any>(data: T[], headerMap?: TableCol<T>[], extraConfig?: {
        prefix?: string;
        hideHeader?: boolean;
    }): Promise<string>;
    /**
     * Checks if a value is a date string in YYYY-MM-DD format
     * @param v Value to check
     * @returns True if value is a date string
     */
    isDateValue: (v: any) => boolean;
    /**
     * Checks if a value is a datetime string in ISO format
     * @param v Value to check
     * @returns True if value is a datetime string
     */
    isDatTimeValue: (v: any) => boolean;
    /**
     * Formats a boolean value as a colored "Yes" or "No" HTML span
     * @param v Boolean value to format
     * @returns HTML string with appropriate styling
     */
    yesNoCellFormatterColoured: (v: any) => string;
    /**
     * Formats a boolean value as "Yes" or "No"
     * @param v Boolean value to format
     * @returns "Yes" or "No" string
     */
    yesNoCellFormatter: (v: any) => string;
    /**
     * Formats a status value as a colored HTML span
     * @param status Status value to format
     * @returns HTML string with appropriate styling
     */
    statusCellFormatter: (status: Status) => string;
    /**
     * Creates a formatter function that applies styling based on value
     * @param guide Object defining values for different styles
     * @returns Formatter function that returns styled HTML
     */
    cellStatusFormatter: <T = any>(guide: {
        successVal?: T;
        pendingVal?: T;
        errorVal?: T;
        inertVal?: T;
    }) => (v: any) => string;
    /**
     * Generates a UUID
     */
    generateUUID: () => string;
    /**
     * Shows an information dialog
     * @param text Text to display
     * @param status Optional status: 0=error, 1=success, 2=info
     * @param heading Optional dialog heading
     * @param btns Optional buttons configuration
     * @param disableClose Whether to disable dialog closing
     * @returns Promise resolving to boolean indicating user action
     */
    info: (text: string, status?: 0 | 2 | 1, heading?: string, btns?: IInfoDialogBtn[], disableClose?: boolean) => Promise<boolean>;
    /**
     * Creates a debounced function
     */
    debouncer: (config: {
        uniqueKey: string;
        callback: () => any;
    }) => void;
    /**
     * Creates an async validator
     */
    asyncValidation: <TData extends {
        response?: boolean;
    } = any>(config: {
        uniqueKey: string;
        callback: () => Promise<TData>;
        validationError?: ets_fe_ng_sdk.CustomValidationError;
    }) => Promise<ets_fe_ng_sdk.CustomValidationError>;
    /**
     * Starts the page loader
     */
    startPl: (value?: number) => number;
    /**
     * Stops the page loader
     */
    stopPl: (value?: number) => number;
    /**
     * Creates a subscription manager to handle multiple subscriptions
     * @param subs Initial subscriptions
     * @returns Object with methods to manage subscriptions
     * @example
     * // Create a subscription manager
     * const subManager = utilityService.createSubscriptionManager();
     *
     * // Add subscriptions to the manager
     * subManager.push(
     *   this.dataService.getData().subscribe(data => this.data = data),
     *   this.userService.getUser().subscribe(user => this.user = user)
     * );
     *
     * // Later, clear all subscriptions at once (e.g., in ngOnDestroy)
     * ngOnDestroy() {
     *   subManager.clear();
     * }
     */
    createSubscriptionManager: (...subs: Subscription[]) => {
        clear: () => void;
        push: (...subs: Subscription[]) => number;
        subs: () => Subscription[];
    };
    /**
     * Creates a cache manager for storing and retrieving data
     * @param config Configuration options
     * @returns Object with methods to manage the cache
     * @example
     * // Create a cache for user data with custom key function
     * const userCache = utilityService.createCacheManager<User, number>({
     *   keyer: (userId) => `user_${userId}`,
     *   maxSize: 50 // Store up to 50 users
     * });
     *
     * // Save data to cache
     * userCache.save(123, { id: 123, name: 'John Doe', email: 'john@example.com' });
     *
     * // Retrieve data from cache
     * const user = userCache.get(123);
     *
     * // Clear cache when needed
     * userCache.clear();
     */
    createCacheManager: <TData = any, TKey = any>(config: {
        keyer?: (item: TKey) => string;
        maxSize?: number;
    }) => {
        clear: () => void;
        destroy: () => void;
        get: (key: TKey) => TData;
        save: (key: string | number | TKey, data: TData) => void;
        cache: () => {
            [key: string]: {
                item: TData;
            };
        };
    };
    /**
     * Track by function that uses a custom ID field
     * @param index Index of the item
     * @param item Item to track
     * @returns Custom ID for the item
     */
    trackByCustomID: (index: any, item: any) => any;
    /**
     * Track by function for form groups
     * @param index Index of the form group
     * @param item Form group to track
     * @returns Custom ID for the form group
     */
    trackByForForms: (index: any, item: FormGroup) => any;
    /**
     * Converts an object to a FormGroup
     * @param data Object to convert
     * @returns FormGroup with controls for each object property
     */
    objectToFormGroup: <T>(data: T) => FormGroup<IStrictFormGroup<T>>;
    /**
     * Times the execution of a code block
     * @param label Label for the timing log
     * @param cb Callback function to execute and time
     * @returns Result of the callback function
     * @example
     * // Time a data processing function
     * const processedData = utilityService.timeCodeBlock('Process user data', () => {
     *   const result = [];
     *   for (let i = 0; i < 10000; i++) {
     *     result.push(this.processUserData(this.users[i]));
     *   }
     *   return result;
     * });
     * // Console output: "Process user data 1621234567890 1621234568920 1.03sec"
     */
    timeCodeBlock: <T>(label: string, cb: () => T) => T;
    /**
     * Removes null, undefined, and empty string fields from an object
     * @param obj Object to clean
     * @returns New object without null, undefined, or empty string fields
     * @example
     * const userData = {
     *   name: 'John',
     *   email: 'john@example.com',
     *   phone: '',
     *   address: null,
     *   age: 30
     * };
     *
     * const cleanData = utilityService.deleteNull(userData);
     * // cleanData = { name: 'John', email: 'john@example.com', age: 30 }
     */
    deleteNull: <T>(obj: T) => T;
    /**
     * Conditionally executes an observable-returning function based on request value
     * @param req The request parameter to check
     * @param observable Function that returns an Observable when given the request
     * @returns The Observable from the function if req has a value, otherwise an Observable of null
     * @template Q Request parameter type
     * @template R Observable response type
     */
    nullRequestHandler: <Q, R>(req: Q, observable: (q: Q) => Observable<R>) => Observable<R>;
    /**
     * Handles errors from Angular's ResourceRef by displaying an error message
     * @param res The ResourceRef object to check for errors
     * @template T The type of data in the ResourceRef
     */
    resouceErrorHandler: <T>(res: ResourceRef<T>) => void;
    /**
     * Formats a time duration in milliseconds to hours, minutes, and seconds
     * @param timeTaken Time in milliseconds
     * @returns Formatted time string
     */
    formatTimeTaken: (timeTaken: number) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UtilityService<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UtilityService<any>>;
}

/**
 * Service for handling input-related functionality across the application.
 * Provides utilities for formatting options, handling date/time inputs, and managing input configurations.
 */
declare class InputService {
    debouncer: DebouncerService;
    uS: UtilityService;
    /** Configuration settings for the input service */
    protected readonly _config: _angular_core.WritableSignal<IInputConfig>;
    /** Computed signal that provides a copy of the current configuration */
    readonly config: _angular_core.Signal<IInputConfig>;
    /** Collection of functions to format different types of option labels */
    readonly optionLabellerFunctions: {
        [x: string]: (option: any) => {
            label: string;
            value: string;
        };
    };
    /** Hours for 12-hour time format (1-12) */
    readonly timeHours: _angular_core.WritableSignal<string[]>;
    /** Hours for 24-hour time format (00-23) */
    readonly time24Hours: _angular_core.WritableSignal<string[]>;
    /** Minutes for time input (00-59) */
    readonly timeMinutes: _angular_core.WritableSignal<string[]>;
    /** Seconds for time input (00-59) */
    readonly timeSeconds: _angular_core.WritableSignal<string[]>;
    /** Delay in milliseconds before showing tooltips */
    readonly matTooltipShowDelay: _angular_core.WritableSignal<number>;
    /** AM/PM options for 12-hour time format */
    readonly timeMeridiem: _angular_core.WritableSignal<{
        label: "am" | "pm";
        incrementor: 0 | 12;
    }[]>;
    /** Map of meridiem values for quick lookup */
    readonly timeMeridiemMap: _angular_core.Signal<{
        [x: string]: {
            _label: string;
            label: "am" | "pm";
            incrementor: 0 | 12;
        };
    }>;
    /** Length requirements for date components (year: 4, month: 2, day: 2) */
    readonly dateLengthIndex: {
        0: number;
        1: number;
        2: number;
    };
    /** Configuration for date/time input chunks (day, month, year, hours, etc.) */
    readonly dateInputChunks: {
        placeholder?: string;
        label: string;
        class: string;
        width: string;
        separator?: string;
        formControlName: string;
        type: InputType;
        length: number;
        isTime?: boolean;
    }[];
    /**
     * Creates a FormGroup for date/time inputs with appropriate controls
     */
    get dateFS(): FormGroup<{
        date: FormControl<Date>;
        hours: FormControl<string>;
        minutes: FormControl<string>;
        seconds: FormControl<string>;
        meridiem: FormControl<number>;
        rawValue: FormControl<string>;
    }>;
    constructor(debouncer: DebouncerService, uS: UtilityService);
    /**
     * Creates a formatter function that concatenates two strings.
     */
    labeller: typeof EVFunctions.strConcatenator;
    /**
     * Formats an array of options into a standardized IOption format.
     *
     * @param options - Array of items to format as options
     * @param config - Configuration for formatting options
     * @param config.valueField - Field to use as the option value
     * @param config.formatter - Custom function to format the option label
     * @param config.labelType - Predefined label type to use for formatting
     * @param config.labelField - Field(s) to use as the option label
     * @param config.optionHintField - Field to use as the option hint
     * @param config.autoPickValueField - Whether to automatically select the value field
     * @returns Array of formatted IOption objects
     */
    optionsFormatter<TRow = any>(options: TRow[], config: {
        valueField?: keyof TRow;
        formatter?: (item: any) => string;
        labelType?: OptionLabelType;
        labelField?: keyof TRow | (keyof TRow)[];
        optionHintField?: keyof TRow;
        autoPickValueField?: boolean;
    }): IOption<TRow>[];
    /**
     * Removes duplicate options based on their value property.
     *
     * @param options - Array of options to filter
     * @returns Array of unique options
     */
    distincter: <T>(options: T[]) => T[];
    /**
     * Logs form data to the console.
     *
     * @param form - Form to log
     */
    log(form: any): void;
    /**
     * Updates the input configuration.
     *
     * @param config - Partial configuration to merge with existing config
     */
    updateConfig(config: Partial<IInputConfig>): void;
    /**
     * Formats user input for date/time fields.
     *
     * @param e - Input event
     * @param form - Form group containing date/time controls
     * @param config - Configuration for date/time formatting
     * @param config.showTime - Whether to display time
     * @param config.id - Unique identifier for the input
     * @param config.use24Hr - Whether to use 24-hour time format
     */
    formatUserInput(e: Event, form: typeof this.dateFS, config: {
        showTime: boolean;
        id: string;
        use24Hr: boolean;
    }): void;
    /**
     * Searches for users based on a query string.
     *
     * @param query - Search query
     * @returns Observable of matching user objects
     */
    searchUsers: (query: string) => Observable<{
        userName?: string;
        fullName?: string;
    }[]>;
    /**
     * Handles content change events for rich text editors.
     *
     * @param $event - Content change event
     * @param form - Form group containing the field
     * @param field - Field name in the form
     */
    onContentChanged: <TF extends { [x in keyof TF]: AbstractControl<any, any>; }>($event: ContentChange, form: FormGroup<TF>, field: keyof TF) => void;
    /**
     * Generates CSS classes for input elements based on validation state.
     *
     * @param inpCl - Base input class
     * @param dirty - Whether the input has been modified
     * @param valid - Whether the input is valid
     * @param invalid - Whether the input is invalid
     * @param showValidation - Whether to show validation styling
     * @returns String of CSS classes
     */
    inputClass: (inpCl: string, dirty?: boolean, valid?: boolean, invalid?: boolean, showValidation?: boolean) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InputService>;
}
/**
 * Interface representing a formatted option for selection components.
 *
 * @template TRow - Type of the original data row
 */
interface IOption<TRow = any> {
    /** Value of the option */
    value: any;
    /** Original data row */
    originalRow: TRow;
    /** Display label for the option */
    label: string;
    /** Unique identifier */
    _id: string;
    /** Optional hint or additional information */
    hint?: string | any;
}

/**
 * Component for date and datetime input with optional time selection
 *
 * Provides a customizable date picker with optional time selection functionality.
 * Supports both 12-hour and 24-hour time formats based on configuration.
 */
declare class DateInputComponent {
    iS: InputService;
    datePipe: DatePipe;
    /** Input type (date or datetime-local) */
    type: string;
    /** Number of input chunks to display based on type */
    chunksLength: number;
    /** Form group for date and time inputs */
    protected readonly form: FormGroup<{
        date: FormControl<Date>;
        hours: FormControl<string>;
        minutes: FormControl<string>;
        seconds: FormControl<string>;
        meridiem: FormControl<number>;
        rawValue: FormControl<string>;
    }>;
    /**
     * Computed property that returns the formatted date/time string
     * Format: "MMM. dd, yyyy" with optional time component
     */
    readonly formattedValue: _angular_core.Signal<string>;
    /** Signal for form value changes */
    readonly formValue: _angular_core.Signal<Partial<{
        date: Date;
        hours: string;
        minutes: string;
        seconds: string;
        meridiem: number;
        rawValue: string;
    }>>;
    /** Output event emitted when the date/time value changes */
    readonly valueChanged: _angular_core.OutputEmitterRef<string>;
    /** Signal indicating whether time selection should be shown */
    readonly showTime: _angular_core.WritableSignal<boolean>;
    /** Flag to prevent circular updates when patching from control */
    skipPatchFromControl: boolean;
    /** Flag to prevent circular updates when patching control */
    skipPatchControl: boolean;
    /** Signal holding the current control value */
    readonly controlValue: _angular_core.WritableSignal<string>;
    /**
     * Sets the value of the date/time input
     * Handles parsing and distributing values to the appropriate form controls
     * @param v ISO date string (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS)
     */
    set value(v: string);
    /** CSS class for the input control background */
    readonly inpCl: _angular_core.InputSignal<string>;
    /** Additional CSS classes for the component */
    readonly cls: _angular_core.InputSignal<string>;
    /** CSS classes specifically for the input element */
    readonly inputClass: _angular_core.InputSignal<string>;
    /** Flag indicating if the input is valid */
    valid: boolean;
    /** Signal for maximum allowed date */
    readonly max: _angular_core.WritableSignal<Date>;
    /**
     * Sets the maximum allowed date
     * @param v Date string or timestamp
     */
    set _max(v: string | number);
    /** Signal for minimum allowed date */
    readonly min: _angular_core.WritableSignal<Date>;
    /**
     * Sets the minimum allowed date
     * @param v Date string or timestamp
     */
    set _min(v: string | number);
    /** ID attribute for the input element */
    readonly id: _angular_core.InputSignal<string>;
    /** Time format type (12H or 24H) */
    readonly timeType: _angular_core.InputSignal<ETimeType>;
    /** Flag indicating if the input is invalid */
    invalid: boolean;
    /** Flag indicating if the input is disabled */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /** Flag to enable debug mode */
    readonly debug: _angular_core.InputSignal<boolean>;
    /** Flag indicating if the input is read-only */
    readonly readonly: _angular_core.InputSignal<boolean>;
    /**
     * Sets the input type and configures time display accordingly
     * @param v Input type ('date' or 'datetime-local')
     */
    set _type(v: InputType);
    /** Flag to control validation display */
    showValidation: boolean;
    /** Reference to the Material Calendar component */
    matCalendar: MatCalendar<any>;
    /** Collection of subscriptions for cleanup */
    subs: {
        [x: string]: Subscription;
    };
    /** Computed property determining whether to use 24-hour format */
    readonly use24Hr: _angular_core.Signal<boolean>;
    /** Computed placeholder text based on input configuration */
    readonly placeholder: _angular_core.Signal<string>;
    /** Computed array of available hours based on time format */
    readonly timeHours: _angular_core.Signal<string[]>;
    /**
     * Creates an instance of DateInputComponent
     * @param iS Input service for shared functionality
     * @param datePipe Angular DatePipe for date formatting
     */
    constructor(iS: InputService, datePipe: DatePipe);
    /**
     * Sets up value change handling and formatting
     * Processes form changes and emits properly formatted date/time strings
     */
    formatterFunction: () => void;
    /**
     * Lifecycle hook for cleanup
     * Unsubscribes from all subscriptions to prevent memory leaks
     */
    ngOnDestroy(): void;
    /**
     * Lifecycle hook that runs after the component view is initialized
     * Sets the calendar's active date if a value exists
     */
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateInputComponent, "date-input", never, { "value": { "alias": "value"; "required": false; }; "inpCl": { "alias": "inpCl"; "required": false; "isSignal": true; }; "cls": { "alias": "cls"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; }; "_max": { "alias": "max"; "required": false; }; "_min": { "alias": "min"; "required": false; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "timeType": { "alias": "timeType"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "_type": { "alias": "type"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
}

declare class CacheService {
    private _cache;
    readonly uS: UtilityService<any>;
    constructor();
    get cache(): {
        [x: string]: any;
    };
    has: (key: string) => boolean;
    getItem: <T>(key: string) => T;
    setItem<T>(key: string, data: T): void;
    getAndSet<T>(key: string, newValue?: T | Promise<T> | Observable<T>): Observable<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CacheService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CacheService>;
}

declare class LocalCacheService extends CacheService {
    private readonly cacheKey;
    private readonly cacheCreatedDateKey;
    private readonly validityDays;
    private readonly oneDayTimestamp;
    readonly sS: ETSStorageService;
    constructor();
    saveToLocal(): void;
    setItem<T>(key: string, data: T): void;
    getAndSet<T>(key: string, addFunc?: T | Promise<T> | Observable<T>): Observable<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocalCacheService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LocalCacheService>;
}

/**
 * Interface for API response structure
 */
interface IResponse {
    message: string;
    result: any;
    status: 'success' | 'error' | 'failure';
    statusCode: 'SM000' | 'SM001' | 'SM002' | 'SM003';
}
/**
 * Service for handling API requests with caching capabilities
 * Provides methods for GET, POST, PUT, PATCH and DELETE HTTP requests
 */
declare class ApiService {
    private showRoutes;
    private get headers();
    protected get fileHeaders(): {
        enctype: string;
    };
    baseURL: string;
    private retryCount;
    http: HttpClient;
    cacheS: CacheService;
    lCacheS: LocalCacheService;
    constructor();
    /**
     * Logs API route information if showRoutes is enabled
     * @param method HTTP method (get, post, put, delete)
     * @param route API endpoint
     * @param extras Additional parameters to log
     */
    private logRoutes;
    /**
     * Handles HTTP request errors
     * @param err HTTP error response
     * @returns Observable error
     */
    protected handleRequestError: (err: HttpErrorResponse) => Observable<never>;
    /**
     * Combines two HttpHeaders objects into one
     * @param headers1 First HttpHeaders object
     * @param headers2 Second HttpHeaders object
     * @returns Combined HttpHeaders
     */
    protected concatenateHeaders: (headers1: HttpHeaders, headers2: HttpHeaders) => HttpHeaders;
    /**
     * Performs a PATCH request
     * @param route API endpoint
     * @param body Request body
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    patch<T = any>(route: string, body?: any, extras?: IAPIConfig): Observable<T>;
    optionsHandler: (extras?: IAPIConfig) => {};
    /**
     * Performs a POST request
     * @param route API endpoint
     * @param body Request body
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    post<T = any>(route: string, body?: any, extras?: IAPIConfig): Observable<T>;
    /**
     * Performs a POST request with FormData
     * @param route API endpoint
     * @param body FormData to send
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    postFile<T = any>(route: string, body: FormData, extras?: IAPIConfig): Observable<T>;
    /**
     * Performs a POST request with FormData and endorsement header
     * @param route API endpoint
     * @param body FormData to send
     * @returns Observable of type T
     */
    postFileWithEndorsement<T = any>(route: string, body: FormData): Observable<T>;
    /**
     * Performs a POST request with text content type
     * @param route API endpoint
     * @param body Request body
     * @param extras Extra configurations for the request
     * @returns Observable of string
     */
    postString(route: string, body?: any, extras?: IAPIConfig): Observable<string>;
    /**
     * Performs a POST request with text content type and local caching
     * @param route API endpoint
     * @param body String body to send
     * @returns Observable of string
     */
    postStringWithLocalCache(route: string, body: string): Observable<string>;
    /**
     * Perform a GET request
     * @param route API endpoint
     * @param parameters Object to convert into queryparams
     * @param extras Extra configurations for the request
     * @returns
     */
    get: <T = any>(route: string, parameters?: IObjectLiteral, extras?: IAPIConfig) => Observable<T>;
    /**
     * Fetches code data and sorts it
     * @param route API endpoint
     * @returns Observable of sorted code data
     */
    getCodes: <T extends ICodeTitle | ICodeDescription = ICodeTitle & ICodeDescription>(route: string) => Observable<T[]>;
    /**
     * Performs a GET request with text response type
     * @param route API endpoint
     * @param parameters Query parameters
     * @param extras Extra configurations for the request
     * @returns Observable of type T (defaults to string)
     */
    getText: <T = string>(route: string, parameters?: {
        [field: string]: string | number | boolean;
    }, extras?: IAPIConfig) => Observable<T>;
    /**
     * Performs a GET request for file download
     * @param route API endpoint
     * @param parameters Query parameters
     * @param extras Extra configurations for the request
     * @returns Observable of type T (defaults to string)
     */
    getFile: <T = string>(route: string, parameters?: {
        [field: string]: string | number | boolean;
    }, extras?: IAPIConfig) => Observable<T>;
    /**
     * Performs a GET request with a request body
     * @param route API endpoint
     * @param body Request body
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    getWithBody: <T = any>(route: string, body?: any, extras?: IAPIConfig) => Observable<T>;
    /**
     * Gets data from local cache or fetches it if not available
     * @param route API endpoint
     * @param parameters Query parameters
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    getFromlocal: <T = any>(route: string, parameters?: Object, extras?: IAPIConfig) => Observable<T>;
    /**
     * Gets data with local caching - returns cached data first, then updates with fresh data
     * @param route API endpoint
     * @param parameters Query parameters
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    getWithLocalCache: <T = any>(route: string, parameters?: Object, extras?: IAPIConfig) => Observable<T>;
    /**
     * Gets data from memory cache or fetches it if not available
     * @param route API endpoint
     * @param parameters Query parameters
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    getFromMemory: <T>(route: string, parameters?: Object, extras?: IAPIConfig) => Observable<T>;
    /**
     * Converts an object to URL query parameters
     * @param parameters Object to convert
     * @returns Query parameter string
     */
    getRequestParse(parameters?: Object): string;
    /**
     * Performs a PUT request
     * @param route API endpoint
     * @param body Request body
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    put<T = any>(route: string, body?: any, extras?: IAPIConfig): Observable<T>;
    /**
     * Performs a PUT request with FormData
     * @param route API endpoint
     * @param body FormData to send
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    putFile<T = any>(route: string, body: FormData, extras?: any): Observable<T>;
    /**
     * Performs a PUT request with FormData and endorsement header
     * @param route API endpoint
     * @param body FormData to send
     * @returns Observable of type T
     */
    putFileWithEndorsement<T = any>(route: string, body: FormData): Observable<T>;
    /**
     * Performs a DELETE request
     * @param route API endpoint
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    delete: <T = any>(route: string, extras?: IAPIConfig) => Observable<any>;
    /**
     * Performs a DELETE request with a request body
     * @param route API endpoint
     * @param body Request body
     * @param extras Extra configurations for the request
     * @returns Observable of type T
     */
    deleteWithBody: <T = any>(route: string, body?: any, extras?: IAPIConfig) => Observable<any>;
    /**
     * Performs a DELETE request with text response type
     * @param route API endpoint
     * @param extras Extra configurations for the request
     * @returns Observable of string
     */
    deleteText: (route: string, extras?: IAPIConfig) => Observable<any>;
    /**
     * Sorts an array of objects by code property
     * @param data Array to sort
     * @returns Sorted array
     */
    sortCodes: <T extends {
        code: string;
    }>(data: T[]) => T[];
    objectToFormData(obj: IObjectLiteral): FormData;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ApiService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ApiService>;
}
/**
 * Interface for extra request configurations
 */
interface IAPIConfig {
    /**
     * Specify whether to use the endorsement header
     */
    useEndorsement?: boolean;
    /**
     * Report progress of the request
     */
    reportProgress?: boolean;
    /**
     * Specify the request options. The added options will be appended to the default options
     */
    options?: {
        headers?: HttpHeaders;
        [x: string]: any;
    };
    /**
     * Specify the request type. If the request type is queryParams, the body will be sent as query parameters
     */
    requestType?: 'queryParams';
    /**If true, the cache record will be recomputed after returning a result */
    refreshCache?: boolean;
    isReturningText?: boolean;
}

/**
 * Service for handling text translations between languages.
 * Manages translation requests, caching, and glossary handling.
 *
 * @template TranslationGlossaryResponse Type of the translation glossary response
 */
declare class TranslationService<TranslationGlossaryResponse = any> {
    apiService: ApiService;
    storageS: ETSStorageService;
    cacheS: CacheService;
    protected baseURL: string;
    /**
     * Matrix to store pending translation requests
     */
    protected readonly translationRequestMatrix: {
        id: string;
        text: string;
    }[];
    /**
     * Subject containing responses for translation requests
     */
    protected translationResponseMatrix: BehaviorSubject<{
        [id: string]: string;
    }>;
    /**
     * Separator used for batch translation requests
     */
    readonly separator = "~~~";
    /**
     * Name of the glossary to use
     */
    get name(): string;
    /**
     * Signal for the source language
     */
    readonly sourceLanguage: _angular_core.WritableSignal<ELanguage>;
    /**
     * Signal for the target language
     */
    readonly targetLanguage: _angular_core.WritableSignal<ELanguage>;
    /**
     * Signal for the translation glossary
     */
    readonly transGlossary: _angular_core.WritableSignal<any>;
    /**
     * Subscription for the interval that processes translation requests
     */
    protected intervalSub: Subscription;
    /**
     * Toast notification service for displaying messages
     */
    readonly toastNotificationService: ToastNotificationsService;
    /**
     * Interval in milliseconds between translation request batches
     */
    interval: number;
    /**
     * Computed route for translation requests
     */
    readonly route: _angular_core.Signal<string>;
    /**
     * Default language to use
     */
    readonly defaultLanguage: _angular_core.WritableSignal<string>;
    /**
     * Computed route for reverse translation requests
     */
    readonly reverseRoute: _angular_core.Signal<string>;
    /**
     * @param apiService Service for making API requests
     * @param storageS Service for storing data
     * @param cacheS Service for caching data
     */
    constructor(apiService: ApiService, storageS: ETSStorageService, cacheS: CacheService);
    /**
     * Transformer function for pipe operations
     */
    pipeTransformer: (text: string | number | boolean, config?: ITranslatorConfig) => Observable<string>;
    /**
     * Starts the interval for processing translation requests
     */
    startInterval(): Promise<void>;
    /**
     * Stops the interval for processing translation requests
     */
    stopInterval(): void;
    /**
     * Tags a string with an ID for batch translation
     * @param id Unique identifier for the text
     * @param str Text to translate
     * @returns Tagged string
     */
    protected tagger(id: string, str: string): string;
    /**
     * Sends a translation request to the API
     * @param body Text to translate
     * @returns Observable with the translated text
     */
    translate(body: string): Observable<string>;
    /**
     * Static version of the translate method
     */
    readonly translateStatic: (...body: Parameters<typeof this.translate>) => Observable<string>;
    /**
     * Sends a reverse translation request to the API
     * @param body Text to translate back to source language
     * @returns Observable with the translated text
     */
    reverseTranslate(body: string): Observable<string>;
    /**
     * Static version of the reverseTranslate method
     */
    readonly reverseTranslateStatic: (...body: Parameters<typeof this.reverseTranslate>) => Observable<string>;
    /**
     * Gets the translation glossary for the specified languages
     * @param sourceLanguage Source language code
     * @param targetLanguage Target language code
     * @returns Observable with the glossary
     */
    getGlossary(sourceLanguage?: ELanguage, targetLanguage?: ELanguage): Observable<any>;
    /**
     * Extracts translated text from tagged response
     * @param str Tagged response string
     * @returns Object mapping IDs to translated text
     */
    detagger(str: string): {};
    /**
     * Legacy method for translating text
     * @param text Text to translate
     * @returns Observable with the translated text
     * @deprecated Use translate method instead
     */
    translateOld(text: string): Observable<string>;
    /**
     * Translates HTML content
     * @param HTMLString HTML string to translate
     * @param sourceLanguage Source language code
     * @param targetLanguage Target language code
     * @param config Translation configuration
     * @returns Observable with the translated HTML
     */
    translateHTML: (HTMLString: string, sourceLanguage?: ELanguage, targetLanguage?: ELanguage, config?: ITranslatorConfig) => Observable<string>;
    /**
     * Mapping for ID generation
     */
    idGeneratorKey: {
        ' ': string;
    };
    /**
     * Generates a unique ID for a text string
     * @param text Input text
     * @returns Generated ID
     */
    idGenerator: (text: string) => string;
    /**
     * Translates plain text
     * @param text Text to translate
     * @param sourceLang Source language code
     * @param targetLang Target language code
     * @returns Promise with the translated text
     */
    plainTranslate: (text: string, sourceLang?: ELanguage, targetLang?: ELanguage) => Promise<string>;
    /**
     * Promise-based version of translateHTML
     * @param text HTML text to translate
     * @param sourceLanguage Source language code
     * @param targetLanguage Target language code
     * @param config Translation configuration
     * @returns Promise with the translated HTML
     */
    translateHTMLPromise: (text: string, sourceLanguage?: ELanguage, targetLanguage?: ELanguage, config?: ITranslatorConfig) => Promise<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslationService<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TranslationService<any>>;
}

/**
 * Base component for all input types in the application.
 * Provides common functionality and properties for various input components.
 *
 * @template TFormGroup - The type of FormGroup this input belongs to
 * @template TControl - The type of the control value
 * @template TOption - The type of options for select-like inputs
 */
declare class InputBase<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any, TControl = any, TOption = any> {
    protected readonly translationService: TranslationService<any>;
    protected readonly cdr: ChangeDetectorRef;
    /** Reference to the DateInputComponent when used */
    readonly dateInputRef: _angular_core.Signal<DateInputComponent>;
    /** CSS class to apply to the input */
    readonly cls: _angular_core.InputSignal<string>;
    /** Hint text to display with the input */
    readonly hint: _angular_core.InputSignal<string | number>;
    /** Whether to avoid formatting this as a standard input */
    readonly dontFormatAsInputSignal: _angular_core.InputSignal<boolean>;
    /** Whether to check for duplicate values */
    readonly duplicateCheckSignal: _angular_core.InputSignal<boolean>;
    /** Whether to use a preset value */
    readonly presetValue: _angular_core.InputSignal<boolean>;
    /** Label to display at the end of the input */
    readonly endLabelSignal: _angular_core.InputSignal<string>;
    /** Tooltip for the end label */
    readonly endLabelTooltipSignal: _angular_core.InputSignal<string>;
    /** Unique ID for the input */
    readonly idSignal: _angular_core.InputSignal<string>;
    /** CSS class for the input container */
    readonly inputContClassSignal: _angular_core.InputSignal<string>;
    /** Label text for the input */
    readonly labelSignal: _angular_core.InputSignal<string>;
    /** CSS class for the label */
    readonly lblCl: _angular_core.InputSignal<string>;
    /** Whether to use light styling */
    readonly light: _angular_core.InputSignal<boolean>;
    /** Whether to disable formatting */
    readonly noFormat: _angular_core.InputSignal<boolean>;
    /** Placeholder text for the input */
    readonly placeholder: _angular_core.InputSignal<string>;
    /** Whether the input is readonly */
    readonly readonlySignal: _angular_core.InputSignal<boolean>;
    /** Whether the input is required */
    readonly requiredSignal: _angular_core.InputSignal<boolean>;
    /** Whether to show the required indicator */
    readonly showRequiredTagSignal: _angular_core.InputSignal<boolean>;
    /** Suffix text for the input */
    readonly suffix: _angular_core.InputSignal<string>;
    /** Number of rows for textarea inputs */
    readonly textareaRowsSignal: _angular_core.InputSignal<number>;
    /** Configuration for translation */
    readonly translatorOptions: _angular_core.InputSignal<ITranslatorConfig>;
    /** Whether to set the formatted value */
    readonly setFormattedValue: _angular_core.InputSignal<boolean>;
    /** Computed property to determine if formatting should be disabled */
    readonly computedNoFormat: _angular_core.Signal<boolean>;
    /** The form group or control this input is bound to */
    readonly form: _angular_core.ModelSignal<FormGroup<TFormGroup> | FormControl<TControl> | AbstractControl<TControl, TControl, any>>;
    /** Whether to show the hint inline instead of as a tooltip */
    readonly inlineHint: _angular_core.InputSignal<boolean>;
    /** Whether to automatically pick the value field from options */
    readonly autoPickValueField: _angular_core.InputSignal<boolean>;
    /** Field(s) to use as the label in options */
    readonly labelField: _angular_core.ModelSignal<keyof TOption | (keyof TOption)[]>;
    /** Field to use for option hints */
    readonly optionHintField: _angular_core.ModelSignal<keyof TOption>;
    readonly ctOptions: _angular_core.InputSignal<ICodeTitle<string>[]>;
    protected readonly ctOptionsEffect: _angular_core.EffectRef;
    readonly vlOptions: _angular_core.InputSignal<IValueLabel<any>[]>;
    protected readonly vlOptionsEffect: _angular_core.EffectRef;
    /** Preset label type for options */
    readonly labelType: _angular_core.ModelSignal<OptionLabelType>;
    /** Custom formatter function for options */
    readonly optionFormatter: _angular_core.InputSignal<(item: TOption) => string>;
    /** Theme to apply to the input */
    readonly theme: _angular_core.InputSignal<InputTheme$1>;
    /** Whether to use extra small styling */
    readonly xsmall: _angular_core.InputSignal<boolean>;
    /** Name of the form control */
    name: _angular_core.ModelSignal<keyof TFormGroup>;
    /** Whether the input is in an indeterminate state (for checkboxes) */
    indeterminate: boolean;
    /** Sets the indeterminate state for checkbox inputs */
    set _indeterminate(v: boolean);
    /** Sets the maximum date to today's date */
    set maxToday(v: boolean);
    /** Sets the minimum date to today's date */
    set minToday(v: boolean);
    /** Field in the option object to use as the value */
    readonly valueField: _angular_core.ModelSignal<keyof TOption>;
    /** Prefix text to display before the input */
    readonly prefixSignal: _angular_core.ModelSignal<string>;
    /** Whether to use minimal styling */
    readonly miniSignal: _angular_core.ModelSignal<boolean>;
    /** CSS class for the input element */
    readonly inpClSignal: _angular_core.ModelSignal<string>;
    /** Whether to show an empty option in select inputs */
    readonly showEmptyOptionSignal: _angular_core.ModelSignal<boolean>;
    /** Whether to show the input label */
    readonly showLabelSignal: _angular_core.ModelSignal<boolean>;
    /** Whether to show validation state */
    readonly showValidationSignal: _angular_core.ModelSignal<boolean>;
    /** Whether to show validation icon */
    readonly showValidationIconSignal: _angular_core.ModelSignal<boolean>;
    /** Whether to use small styling */
    readonly smallSignal: _angular_core.ModelSignal<boolean>;
    /** Whether to show validation messages */
    readonly showValidationMsgSignal: _angular_core.ModelSignal<boolean>;
    /** Whether to use stacked layout (label above input) */
    readonly stackedSignal: _angular_core.InputSignal<boolean>;
    /** Whether to enable debug mode */
    readonly debug: _angular_core.InputSignal<boolean>;
    /** Whether to enable verbose logging */
    readonly verbose: _angular_core.InputSignal<boolean>;
    /** Type of time input to use */
    readonly timeType: _angular_core.InputSignal<ETimeType>;
    /** Whether to check parent disabled state before disabling */
    readonly checkParentBeforeDisable: _angular_core.ModelSignal<boolean>;
    /** Whether to clear the value when disabling the input */
    readonly clearOnDisable: _angular_core.InputSignal<boolean>;
    /** Minimum length for text inputs */
    readonly minLength: _angular_core.InputSignal<number>;
    /** Maximum length for text inputs */
    readonly maxLength: _angular_core.InputSignal<number>;
    /** Sets the disabled state of the input */
    set _disabled(v: boolean);
    /**
     * Handles enabling or disabling the form control
     * @param control - The form control to enable/disable
     * @param disable - Whether to disable the control
     */
    protected disableFunc: (control: (0 extends 1 & TFormGroup ? {
        [key: string]: AbstractControl<any, any, any>;
    } : TFormGroup)[keyof (0 extends 1 & TFormGroup ? {
        [key: string]: AbstractControl<any, any, any>;
    } : TFormGroup)], disable: boolean) => void;
    /** Sets the input type */
    set _type(v: InputType);
    /** Whether to show the password (for password inputs) */
    readonly showPasswordSignal: _angular_core.WritableSignal<boolean>;
    /** Whether the input is currently disabled */
    readonly disabledSignal: _angular_core.Signal<boolean>;
    /** Original input type before any transformations */
    readonly oTypeSignal: _angular_core.WritableSignal<InputType>;
    /** Current input type */
    readonly typeSignal: _angular_core.WritableSignal<InputType>;
    /** Maximum value for number inputs or maximum date for date inputs */
    readonly maxSignal: _angular_core.ModelSignal<string | number>;
    /** Minimum value for number inputs or minimum date for date inputs */
    readonly minSignal: _angular_core.ModelSignal<string | number>;
    /** Whether to show the label based on showLabel and label values */
    readonly computedShowLabel: _angular_core.Signal<boolean>;
    /** Input service for common input functionality */
    iS: InputService;
    /** Computed signal to get the current form control */
    readonly control: _angular_core.Signal<(0 extends 1 & TFormGroup ? {
        [key: string]: AbstractControl<any, any, any>;
    } : TFormGroup)[keyof (0 extends 1 & TFormGroup ? {
        [key: string]: AbstractControl<any, any, any>;
    } : TFormGroup)]>;
    readonly onControlObtainedEffect: _angular_core.EffectRef;
    /**
     * Adds a function to be called when the control is obtained
     * @param key - Unique identifier for the hook
     * @param func - Function to execute when control is available
     */
    readonly addOnControlObtainedHook: (key: string, func: (control: ReturnType<typeof this.control>) => any) => void;
    /** Observable of value changes from the control */
    readonly valueChanges: rxjs.Observable<any>;
    readonly formChangedRes: _angular_core.ResourceRef<_angular_forms.ControlEvent<any>>;
    readonly formFieldNotifier: _angular_core.Signal<_angular_forms.ControlEvent<any>>;
    /** Signal for whether the input is valid */
    readonly validSignal: _angular_core.Signal<boolean>;
    /** Signal for whether the input is invalid */
    readonly invalidSignal: _angular_core.Signal<boolean>;
    /** Signal for the current value of the input */
    readonly valueSignal: _angular_core.Signal<any>;
    /** Signal for whether the input has a value */
    readonly hasValue: _angular_core.Signal<boolean>;
    /** Signal for whether a checkbox input is invalid */
    readonly invalidCheckboxSignal: _angular_core.Signal<boolean>;
    /** Signal for whether the input is dirty */
    readonly dirtySignal: _angular_core.Signal<boolean>;
    /** Signal for whether the input has been touched */
    readonly touchedSignal: _angular_core.Signal<boolean>;
    /** Signal for the current validation errors */
    readonly errorsSignal: _angular_core.Signal<IObjectLiteral<any>>;
    /** JSON string of the current errors */
    readonly errorsSignaljson: _angular_core.Signal<string>;
    /** Signal for whether validation is pending */
    readonly pendingSignal: _angular_core.Signal<boolean>;
    /** Signal for whether the input is pristine */
    readonly pristineSignal: _angular_core.Signal<boolean>;
    /** Signal for whether the control has a required validator */
    readonly controlRequiredSignal: _angular_core.Signal<boolean>;
    /** Signal for whether the input is required (either explicitly or via validator) */
    readonly isRequiredSignal: _angular_core.Signal<boolean>;
    /** Signal for the name of the input as a string */
    readonly nameStrSignal: _angular_core.Signal<string>;
    /** Signal for the CSS class to apply to the input */
    readonly inputClassSignal: _angular_core.Signal<string>;
    /** Whether to use colored styling */
    readonly coloredSignal: _angular_core.InputSignal<boolean>;
    /** Whether the checkbox is checked (for checkbox inputs) */
    readonly checkedSignal: _angular_core.InputSignal<boolean>;
    /** Raw options before formatting */
    readonly rawOptionsSignal: _angular_core.WritableSignal<any[]>;
    /** Resource for loading and formatting options */
    readonly optionsResource: _angular_core.ResourceRef<{
        label: string;
        value: any;
        originalRow: TOption;
        _id: string;
        hint?: string | any;
    }[]>;
    /** Formatted options for select-like inputs */
    readonly options: _angular_core.Signal<IOption<any>[]>;
    /** Whether options are currently loading */
    readonly optionsLoading: _angular_core.Signal<boolean>;
    /** Map of option values to option objects */
    readonly optionsMap: _angular_core.Signal<{
        [value: string]: IOption<any>;
    }>;
    protected readonly doesOptionExist: (val: any) => IOption<any>;
    /**Actions to perform when a new control is created */
    protected readonly onControlObtainedMap: _angular_core.WritableSignal<{
        [key: string]: (control: ReturnType<any>) => any;
    }>;
    /**Actions to perform when a new control is created */
    readonly onControlObtainedList: _angular_core.Signal<((control: ReturnType<any>) => any)[]>;
    /** Output event for value changes */
    readonly mchange: _angular_core.OutputEmitterRef<any>;
    /** Output event for option selection */
    readonly mSelectOptionChange: _angular_core.OutputEmitterRef<TOption>;
    /** Currently selected option */
    readonly selectedOption: _angular_core.Signal<IOption<any>>;
    /**
     * Constructor for InputBase
     * Sets up effects for label propagation and preset values
     */
    constructor();
    /**
     * Handles selection of an option
     * @param option - The selected option
     */
    protected selectOption(option: IOption): void;
    /**
     * Handles date changes from date inputs
     * @param value - The new date value
     */
    dateChanged(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputBase<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputBase<any, any, any>, "ng-component", never, { "cls": { "alias": "cls"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "dontFormatAsInputSignal": { "alias": "dontFormatAsInput"; "required": false; "isSignal": true; }; "duplicateCheckSignal": { "alias": "duplicateCheck"; "required": false; "isSignal": true; }; "presetValue": { "alias": "presetValue"; "required": false; "isSignal": true; }; "endLabelSignal": { "alias": "endLabel"; "required": false; "isSignal": true; }; "endLabelTooltipSignal": { "alias": "endLabelTooltip"; "required": false; "isSignal": true; }; "idSignal": { "alias": "id"; "required": false; "isSignal": true; }; "inputContClassSignal": { "alias": "inputContClass"; "required": false; "isSignal": true; }; "labelSignal": { "alias": "label"; "required": false; "isSignal": true; }; "lblCl": { "alias": "lblCl"; "required": false; "isSignal": true; }; "light": { "alias": "light"; "required": false; "isSignal": true; }; "noFormat": { "alias": "noFormat"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readonlySignal": { "alias": "readonly"; "required": false; "isSignal": true; }; "requiredSignal": { "alias": "required"; "required": false; "isSignal": true; }; "showRequiredTagSignal": { "alias": "showRequiredTag"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "textareaRowsSignal": { "alias": "textareaRows"; "required": false; "isSignal": true; }; "translatorOptions": { "alias": "translatorOptions"; "required": false; "isSignal": true; }; "setFormattedValue": { "alias": "setFormattedValue"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "inlineHint": { "alias": "inlineHint"; "required": false; "isSignal": true; }; "autoPickValueField": { "alias": "autoPickValueField"; "required": false; "isSignal": true; }; "labelField": { "alias": "labelField"; "required": false; "isSignal": true; }; "optionHintField": { "alias": "optionHintField"; "required": false; "isSignal": true; }; "ctOptions": { "alias": "ctOptions"; "required": false; "isSignal": true; }; "vlOptions": { "alias": "vlOptions"; "required": false; "isSignal": true; }; "labelType": { "alias": "labelType"; "required": false; "isSignal": true; }; "optionFormatter": { "alias": "optionFormatter"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "xsmall": { "alias": "xsmall"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "_indeterminate": { "alias": "indeterminate"; "required": false; }; "maxToday": { "alias": "maxToday"; "required": false; }; "minToday": { "alias": "minToday"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; "isSignal": true; }; "prefixSignal": { "alias": "prefix"; "required": false; "isSignal": true; }; "miniSignal": { "alias": "mini"; "required": false; "isSignal": true; }; "inpClSignal": { "alias": "inpCl"; "required": false; "isSignal": true; }; "showEmptyOptionSignal": { "alias": "showEmptyOption"; "required": false; "isSignal": true; }; "showLabelSignal": { "alias": "showLabel"; "required": false; "isSignal": true; }; "showValidationSignal": { "alias": "showValidation"; "required": false; "isSignal": true; }; "showValidationIconSignal": { "alias": "showValidationIcon"; "required": false; "isSignal": true; }; "smallSignal": { "alias": "small"; "required": false; "isSignal": true; }; "showValidationMsgSignal": { "alias": "showValidationMsg"; "required": false; "isSignal": true; }; "stackedSignal": { "alias": "stacked"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "verbose": { "alias": "verbose"; "required": false; "isSignal": true; }; "timeType": { "alias": "timeType"; "required": false; "isSignal": true; }; "checkParentBeforeDisable": { "alias": "checkParentBeforeDisable"; "required": false; "isSignal": true; }; "clearOnDisable": { "alias": "clearOnDisable"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; }; "_type": { "alias": "type"; "required": false; }; "maxSignal": { "alias": "max"; "required": false; "isSignal": true; }; "minSignal": { "alias": "min"; "required": false; "isSignal": true; }; "coloredSignal": { "alias": "colored"; "required": false; "isSignal": true; }; "checkedSignal": { "alias": "checkedSignal"; "required": false; "isSignal": true; }; }, { "form": "formChange"; "labelField": "labelFieldChange"; "optionHintField": "optionHintFieldChange"; "labelType": "labelTypeChange"; "name": "nameChange"; "valueField": "valueFieldChange"; "prefixSignal": "prefixChange"; "miniSignal": "miniChange"; "inpClSignal": "inpClChange"; "showEmptyOptionSignal": "showEmptyOptionChange"; "showLabelSignal": "showLabelChange"; "showValidationSignal": "showValidationChange"; "showValidationIconSignal": "showValidationIconChange"; "smallSignal": "smallChange"; "showValidationMsgSignal": "showValidationMsgChange"; "checkParentBeforeDisable": "checkParentBeforeDisableChange"; "maxSignal": "maxChange"; "minSignal": "minChange"; "mchange": "mchange"; "mSelectOptionChange": "mSelectOptionChange"; }, never, never, true, never>;
}
type InputTheme$1 = 1 | 2;

/**
 * A versatile input component that supports various input types including text, number, select, checkbox, etc.
 * Extends InputBase to provide common input functionality with additional features.
 *
 * @template TFormGroup - The type of form group this input belongs to
 * @template TControl - The type of control value
 * @template TOption - The type of options for select/autocomplete inputs
 */
declare class InputBasicComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any, TControl = any, TOption = any> extends InputBase<TFormGroup, TControl, TOption> implements OnInit {
    /** File types accepted by file input */
    accept: string;
    /** Whether to enable browser autocomplete */
    autocomplete: boolean;
    /** Input configuration object */
    inp: FCInput;
    /** Additional context data for the input */
    contextData: any;
    /** Number of decimal points for number inputs */
    decimalPoints: number;
    /** Files selected in file input */
    files: File[];
    /** Whether to hide the input */
    hide: boolean;
    /** Whether to clear the input value when disabled */
    readonly clearOnDisable: _angular_core.InputSignal<boolean>;
    /** URL for the label link */
    labelLink: string;
    /** Whether the input is in loading state */
    readonly loading: _angular_core.ModelSignal<boolean>;
    /** Whether to allow multiple selections/files */
    multiple: boolean;
    /** Function to fetch options asynchronously */
    optionsFunc: (...val: any) => Observable<any[]>;
    /** Custom validation messages */
    vms: IValidationMessage[];
    /** Emits the selected option's label */
    mSelectedOptionLabel: EventEmitter<string>;
    /** Subject for options data */
    options$: ReplaySubject<IOption<any>[]>;
    /** Whether view has been initialized */
    viewInited: boolean;
    /** Whether value has been forcefully patched */
    forcePatched: boolean;
    /**
     * Sets the current date as the input value
     * @param v - Whether to set current date
     */
    set _setCurrentDate(v: boolean);
    /**
     * Sets the options for select/autocomplete inputs
     * @param v - Array of options
     */
    set _options(v: TOption[] | null);
    /** Reference to the MatSelect element */
    matSelect: MatSelect;
    constructor();
    /**
     * Initializes the component, setting default values and configurations
     */
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Disables the control if the disabled signal is true
     * @param control - The control to disable (defaults to this.control())
     */
    disableControl(control?: AbstractControl): void;
    /**
     * Handles value changes and applies validation rules
     * @param e - The change event
     */
    change(e: {
        target: {
            checked?: boolean;
            value: any;
        };
    } | Event): void;
    /**
     * Handles file uploads
     * @param e - The file input change event
     */
    upload(e: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputBasicComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputBasicComponent<any, any, any>, "app-input-basic,app-input", never, { "accept": { "alias": "accept"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "inp": { "alias": "input"; "required": false; }; "contextData": { "alias": "contextData"; "required": false; }; "decimalPoints": { "alias": "decimalPoints"; "required": false; }; "files": { "alias": "files"; "required": false; }; "hide": { "alias": "hide"; "required": false; }; "clearOnDisable": { "alias": "clearOnDisable"; "required": false; "isSignal": true; }; "labelLink": { "alias": "labelLink"; "required": false; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; }; "optionsFunc": { "alias": "optionsFunc"; "required": false; }; "vms": { "alias": "vms"; "required": false; }; "_setCurrentDate": { "alias": "setCurrentDate"; "required": false; }; "_options": { "alias": "options"; "required": false; }; }, { "loading": "loadingChange"; "mSelectedOptionLabel": "mSelectedOptionLabel"; }, never, never, true, never>;
}

/**
 * Component that supports both Template-Driven and Reactive Forms approaches.
 * Extends the basic input component with form control functionality.
 *
 * @template TOption - The type of options for select/dropdown inputs
 */
declare class InputTD_RFComponent<TOption = any> extends InputBasicComponent<any, any, TOption> {
    /** Array of synchronous validators applied to the form control */
    validators: ValidatorFn[];
    /**
     * Sets the synchronous validators for the form control
     * @param v - Array of validator functions to apply
     */
    set _validators(v: ValidatorFn[]);
    /** Array of asynchronous validators applied to the form control */
    asyncValidators: AsyncValidatorFn[];
    /**
     * Sets the asynchronous validators for the form control
     * @param v - Array of async validator functions to apply
     */
    set _asyncValidators(v: AsyncValidatorFn[]);
    /** The model value bound to this input */
    private model;
    /**
     * Sets the model value and updates the form control
     * @param v - The new model value
     */
    set _model(v: any);
    /** Event emitter that fires when the model value changes */
    modelChange: EventEmitter<any>;
    /** Subscription to value changes that updates the model and emits changes */
    protected valueChanges2: rxjs.Subscription;
    /**
     * Initializes the component with default values
     */
    constructor();
    /**
     * Lifecycle hook that initializes the form group and control
     * @override
     */
    ngOnInit(): void;
    /**
     * Lifecycle hook that handles changes to component inputs
     * @param changes - The changes object containing all changed inputs
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Lifecycle hook called after the view is initialized
     * @override
     */
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTD_RFComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputTD_RFComponent<any>, "app-input-td-rf", never, { "_validators": { "alias": "validators"; "required": false; }; "_asyncValidators": { "alias": "asyncValidators"; "required": false; }; "_model": { "alias": "model"; "required": false; }; }, { "modelChange": "modelChange"; }, never, never, true, never>;
}

/**
 * Service for handling autocomplete functionality
 * Provides methods for filtering, normalizing, and displaying autocomplete options
 */
declare class AutocompleteService {
    uS: UtilityService;
    /**
     * Creates a custom validation error for invalid selections
     * @param label - The label that was not found in the list
     * @returns A CustomValidationError object
     */
    readonly invalidSelectionError: (label: string) => CustomValidationError;
    /**
     * @param uS - Utility service instance
     */
    constructor(uS: UtilityService);
    /**
     * Filters options based on a search query
     * @param query - The search string to filter by
     * @param options - Array of options to filter
     * @returns Filtered array of options, prioritizing those that start with the query
     * @typeParam T - Option type that extends an object with a _normalizedLabel property
     */
    filterOptions<T extends {
        _normalizedLabel: string;
    }>(query: string, options: T[]): T[];
    /**
     * Normalizes a string value by converting to lowercase and removing spaces
     * @param value - The string to normalize
     * @returns Normalized string or undefined if input is falsy
     */
    normalizeValue(value: string): string;
    /**
     * Converts standard options to autocomplete options by adding normalized labels
     * @param options - Array of IOption objects to normalize
     * @returns Array of IAutoCompleteOption objects with normalized labels
     */
    normalizeOptions: (options: IOption[]) => IAutoCompleteOption[];
    /**
     * Creates a display function for Angular mat-autocomplete
     * @param options - Array of options to search through
     * @returns Function that returns the label for a given value
     */
    displayWith: (options: any[]) => (val: any) => any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AutocompleteService>;
}
/**
 * Interface extending IOption with a normalized label property
 */
interface IAutoCompleteOption extends IOption {
    /** Normalized version of the option label for case-insensitive comparison */
    _normalizedLabel: string;
}

/**
 * Component that provides autocomplete functionality with support for both template-driven and reactive forms.
 * Extends InputTD_RFComponent to provide input field capabilities with autocomplete features.
 *
 * @template TOption - The type of options used in the autocomplete dropdown
 */
declare class AutocompleteTdRfComponent<TOption> extends InputTD_RFComponent<TOption> {
    autoS: AutocompleteService;
    /** Computed signal that normalizes the options for the autocomplete */
    readonly cOptions: _angular_core.Signal<ets_fe_ng_sdk.IAutoCompleteOption[]>;
    /** Signal that filters options based on the current input value */
    readonly filteredOptions: _angular_core.WritableSignal<ets_fe_ng_sdk.IAutoCompleteOption[]>;
    /** Whether to validate the selected option against available options */
    validate: boolean;
    /**
     * Sets the options for the autocomplete dropdown
     * Overrides the parent class setter to update the control value when options change
     */
    set _options(v: TOption[]);
    /** Reference to the MatAutocomplete component */
    readonly autoCompleteRef: _angular_core.Signal<MatAutocomplete>;
    /** References to all MatOption components in the autocomplete */
    protected readonly matOptions: _angular_core.Signal<readonly MatOption<any>[]>;
    /** Flag to bypass the option existence validation check */
    readonly skipDoesOptionExistCheck: _angular_core.ModelSignal<boolean>;
    /** Subject that emits when the input value changes to trigger option fetching */
    protected valueChanged: ReplaySubject<string>;
    /** Effect that retriggers the displayWith function when options map changes */
    readonly retriggerDisplayWith: _angular_core.EffectRef;
    /**
     * Creates an instance of AutocompleteTdRfComponent.
     * @param autoS - Service that provides autocomplete functionality
     */
    constructor(autoS: AutocompleteService);
    /**
     * Initializes the component, sets up validators and subscriptions
     * @override
     */
    ngOnInit(): void;
    /**
     * Triggers fetching options from the optionsFunc if provided
     */
    fetchOptions(): void;
    /**
     * Lifecycle hook called after the view is initialized
     * @override
     */
    ngAfterViewInit(): void;
    /**
     * Handles the selection of an option from the autocomplete dropdown
     * @param $event - The MatAutocompleteSelectedEvent
     */
    selected($event: MatAutocompleteSelectedEvent): void;
    /**
     * Function used by the autocomplete to display the selected value
     * @param val - The value to display
     * @returns The label for the value or the value itself
     */
    displayWith: (val: any) => any;
    /**
     * Validator function that checks if the selected value exists in the options
     * @param control - The form control to validate
     * @returns Validation error or null if valid
     */
    includesOption: (control: AbstractControl) => ets_fe_ng_sdk.CustomValidationError;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteTdRfComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteTdRfComponent<any>, "autocomplete-td-rf,app-autocomplete-td-rf", never, { "validate": { "alias": "validate"; "required": false; }; "_options": { "alias": "options"; "required": false; }; "skipDoesOptionExistCheck": { "alias": "skipDoesOptionExistCheck"; "required": false; "isSignal": true; }; }, { "skipDoesOptionExistCheck": "skipDoesOptionExistCheckChange"; }, never, never, true, never>;
}

/**
 * Angular component that provides autocomplete functionality.
 * Extends InputBasicComponent to provide form control integration.
 *
 * @template TFormGroup - The type of form group this component is part of
 * @template TControl - The type of the control value
 * @template TOption - The type of options displayed in the autocomplete
 */
declare class AutocompleteComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any, TControl = any, TOption = any> extends InputBasicComponent<TFormGroup, TControl, TOption> {
    /** Computed signal that normalizes the options for the autocomplete */
    readonly cOptions: _angular_core.Signal<ets_fe_ng_sdk.IAutoCompleteOption[]>;
    /** Linked signal that filters options based on the current input value */
    readonly filteredOptions: _angular_core.WritableSignal<ets_fe_ng_sdk.IAutoCompleteOption[]>;
    /** Whether to show the required tag in the UI */
    showRequiredTag: boolean;
    /** Whether to validate the input */
    validate: boolean;
    /** Signal to control whether to skip the option existence check during validation */
    readonly skipDoesOptionExistCheck: _angular_core.ModelSignal<boolean>;
    /**
     * Setter for options input that overrides the parent class implementation
     * Updates the control value when options change and autocomplete is initialized
     */
    set _options(v: TOption[] | null);
    /** Reference to the MatAutocomplete component */
    readonly autoCompleteRef: _angular_core.Signal<MatAutocomplete>;
    /** References to all MatOption components in the autocomplete */
    protected readonly matOptions: _angular_core.Signal<readonly MatOption<any>[]>;
    /** Computed signal that returns the label of the currently selected option */
    protected readonly selectedMatOptionLabel: _angular_core.Signal<string>;
    /** Subject that emits when the input value changes */
    protected valueChanged: ReplaySubject<string>;
    /** Service that provides autocomplete functionality */
    autoS: AutocompleteService;
    /**
     * Initializes the component
     * Sets up validators and subscribes to value changes if optionsFunc is provided
     */
    ngOnInit(): void;
    /**
     * Cleans up resources when the component is destroyed
     * Removes validators added by this component
     */
    ngOnDestroy(): void;
    /**
     * Fetches options using the optionsFunc if provided
     */
    fetchOptions(): void;
    /**
     * Handles selection of an option from the autocomplete dropdown
     * @param $event - The selection event containing the selected option
     */
    selected($event: MatAutocompleteSelectedEvent): void;
    /**
     * Effect that retriggers the displayWith function when optionsMap changes
     */
    readonly retriggerDisplayWith: _angular_core.EffectRef;
    /**
     * Function used by the autocomplete to display the selected value
     * @param val - The value to display
     * @returns The label for the value, or the value itself if no label is found
     */
    displayWith: (val: any) => any;
    /**
     * Validator function that checks if the selected value exists in the options
     * @param control - The form control to validate
     * @returns Validation error if the value doesn't exist in options, null otherwise
     */
    includesOption: (control: AbstractControl) => ets_fe_ng_sdk.CustomValidationError;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteComponent<any, any, any>, "app-autocomplete,autocomplete", never, { "showRequiredTag": { "alias": "showRequiredTag"; "required": false; }; "validate": { "alias": "validate"; "required": false; }; "skipDoesOptionExistCheck": { "alias": "skipDoesOptionExistCheck"; "required": false; "isSignal": true; }; "_options": { "alias": "options"; "required": false; }; }, { "skipDoesOptionExistCheck": "skipDoesOptionExistCheckChange"; }, never, never, true, never>;
}

declare const AutocompleteModule: readonly [typeof AutocompleteComponent, typeof AutocompleteTdRfComponent];

interface IUADeletionPayload {
    id: number;
    selected: boolean;
}
interface IUASearchObj {
    loggedTimeFrom: string;
    loggedTimeTo: string;
    pageNumber: number;
    pageSize: number;
    pageTitle: string;
    screen: string;
    sortBy: string;
    userAgent: string;
    userName: string;
}
interface IUASearchResponse {
    id: number;
    userName?: string;
    loggedIn: boolean;
    ipAddress: string;
    loggedTime: string;
    userAgent: string;
    pageUrl?: string;
    screen?: string;
    pageTitle: string;
    activityDescription?: string;
    requestUrl?: string;
    requestMethod?: string;
    companyCode?: string;
}
interface IUserActivity {
    id?: number;
    activityDescription?: string;
    pageTitle?: string;
    pageUrl?: string;
    requestMethod?: string;
    requestUrl?: string;
    code: EUA | string;
}
declare class UserActivity implements IUserActivity {
    id: number;
    activityDescription: string;
    pageTitle: string;
    pageUrl: string;
    requestMethod: string;
    requestUrl: string;
    code: EUA;
    constructor(data: IUserActivity);
}
declare enum EUA {
    exported = "export",
    visited = "visited",
    searched = "searched",
    downloaded = "downloaded",
    clicked = "clicked"
}

declare class UserActivityService {
    private newActivity;
    private activities;
    submissionFunc: (activities: UserActivity[]) => Observable<any>;
    constructor();
    readonly allowLogging: _angular_core.Signal<boolean>;
    add(data: IUserActivity): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserActivityService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UserActivityService>;
}

/**
 * Service for managing button configurations, icons, and interactions.
 * Provides centralized button styling, icon mapping, and user activity logging.
 */
declare class BtnService {
    uaS: UserActivityService;
    /**
     * Configuration for button classes based on button type
     */
    btnClassConfig: BtnClass;
    /**
     * Mapping of icon types to their corresponding FontAwesome icons or CSS classes
     */
    buttonIconIndex: {
        [k in IconType]?: {
            icon?: IconDefinition;
            iconString?: string;
            iconPosition?: 'right' | 'left';
        };
    };
    /**
     * Default translator configuration options
     */
    readonly translatorOptions: _angular_core.WritableSignal<ITranslatorConfig>;
    constructor(uaS: UserActivityService);
    /**
     * Retrieves the icon configuration for a given icon type
     * @param iconType - The type of icon to retrieve
     * @returns The icon configuration object or undefined if not found
     */
    getIcon: (iconType: IconType) => {
        icon?: IconDefinition;
        iconString?: string;
        iconPosition?: "right" | "left";
    };
    /**
     * Gets the button class configuration for a specific button type
     * @param v - The button type
     * @returns The button class configuration or a default primary type if not found
     */
    getType(v: BtnType): {
        _mclass?: string;
        _icon?: IconType;
        _type?: BtnType;
    };
    /**
     * Default button type to use when none is specified
     */
    defaultType: BtnType;
    /**
     * Logs a button click event to the user activity service
     * @param btn - The button component that was clicked
     */
    logClick(btn: {
        excludeLogging: boolean;
        extractText: string;
    }): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BtnService>;
}
/**
 * Type definition for button class configurations mapped by button type
 */
type BtnClass = {
    [k in BtnType]: {
        _mclass?: string;
        _icon?: IconType;
        _type?: BtnType;
    };
};

/**
 * A versatile button component that supports various styles, icons, and states.
 * Can be integrated with Angular forms to enable/disable based on form validity.
 */
declare class BtnComponent implements OnInit {
    /** Service for button-related functionality */
    btnS: BtnService;
    /** Change detector reference for manual change detection */
    protected cdr: ChangeDetectorRef;
    /** Form schema to check for specific invalid form fields */
    readonly formSchema: _angular_core.InputSignal<{
        field: string | number | boolean | symbol;
    }[]>;
    /** Enables debug mode for troubleshooting */
    readonly debug: _angular_core.InputSignal<boolean>;
    /**
     * Computed property that determines if the form has invalid fields
     * based on the provided form schema
     */
    readonly formIsInvalid: _angular_core.Signal<boolean>;
    /** Centers the button content when true */
    readonly centerBtn: _angular_core.InputSignal<boolean>;
    /** Applies danger styling to the button */
    readonly danger: _angular_core.InputSignal<boolean>;
    /** Applies warning styling to the button */
    readonly warning: _angular_core.InputSignal<boolean>;
    /** Enables verbose mode for additional information */
    readonly verbose: _angular_core.InputSignal<boolean>;
    /** Configuration options for the translator */
    readonly translatorOptions: _angular_core.InputSignal<ITranslatorConfig>;
    /** Type of icon to be displayed */
    protected iconType: IconType;
    /** Indicates if the button should be displayed as an icon button */
    readonly iconBtn: _angular_core.WritableSignal<boolean>;
    /** Controls the loading state of the button */
    readonly loading: _angular_core.ModelSignal<boolean>;
    /**
     * Computed CSS classes for the button based on various states
     */
    readonly ngClass: _angular_core.Signal<{
        changecolor: boolean;
        'btn-raised': boolean;
        disabled: boolean;
        isDanger: boolean;
        isWarning: boolean;
        invalid: boolean;
        'justify-content-center': boolean;
    }>;
    /** Shows the left disabled icon when appropriate */
    readonly showLeftDisabledIcon: _angular_core.Signal<boolean>;
    /** Shows the left custom icon when appropriate */
    readonly showLeftCustomIcon: _angular_core.Signal<boolean>;
    /** Shows the left icon when appropriate */
    readonly showLeftIcon: _angular_core.Signal<boolean>;
    /** Shows the right disabled icon when appropriate */
    readonly showRightDisabledIcon: _angular_core.Signal<boolean>;
    /** Shows the right custom icon when appropriate */
    readonly showRightCustomIcon: _angular_core.Signal<boolean>;
    /** Shows the right icon when appropriate */
    readonly showRightIcon: _angular_core.Signal<boolean>;
    /**
     * Sets the icon for the button
     * @param v The icon type to use
     */
    set _icon(v: IconType);
    /**
     * Sets the right icon for the button
     * @param v The icon type to use
     */
    set _rightIcon(v: IconType);
    /**
     * Sets the left icon for the button
     * @param v The icon type to use
     */
    set _leftIcon(v: IconType);
    /**
     * Sets the button type which determines its appearance
     * @param v The button type to use
     */
    set _type(v: BtnType);
    /**
     * Sets predefined button configurations based on common use cases
     * @param v The button group to use
     */
    set _group(v: BtnGroup);
    /** CSS class for the button */
    readonly _mclass: _angular_core.WritableSignal<string>;
    /** HTML button type (submit, button, reset) */
    readonly actionType: _angular_core.InputSignal<"submit" | "button" | "reset">;
    /** Enables animation effect on the button */
    readonly animate: _angular_core.InputSignal<boolean>;
    /** Excludes this button from logging when true */
    excludeLogging: boolean;
    /** Value to include in logs when button is clicked */
    loggingValue: string;
    /** Badge text or number to display on the button */
    readonly badge: _angular_core.InputSignal<string | number>;
    /** Additional CSS classes for the button */
    readonly class: _angular_core.InputSignal<string>;
    /**
     * Sets the left side custom icon
     * @param v Icon class string
     */
    set customIcon(v: string);
    /** Form to bind to the button for validation */
    readonly form: _angular_core.InputSignal<AbstractControl<any, any, any> | FormGroup<any> | FormArray<any> | FormControl<any>>;
    /** Subject for form changes */
    protected readonly formStateRes: _angular_core.ResourceRef<boolean>;
    /** Signal for form validity state */
    protected readonly formState: _angular_core.Signal<boolean>;
    /** Multiple forms to bind to the button for validation */
    readonly forms: _angular_core.InputSignal<(AbstractControl<any, any, any> | FormGroup<any> | FormArray<any> | FormControl<any>)[]>;
    /** Signal for multiple forms validity state */
    protected readonly formsStateRes: _angular_core.ResourceRef<Omit<IFormState, "status">>;
    protected readonly formsState: _angular_core.Signal<boolean>;
    /** Tooltip message to display */
    readonly help: _angular_core.InputSignal<string>;
    /** Delay before showing tooltip in milliseconds */
    readonly helpShowDelay: _angular_core.InputSignal<NumberInput>;
    /**
     * @deprecated no longer needed to detect the correct spacing between icon and text
     * Sets whether this is an icon button
     */
    set _iconBtn(v: boolean);
    /** Material class for the button */
    readonly mclass: _angular_core.InputSignal<string>;
    /** Shows help icon when true */
    readonly showHelpIcon: _angular_core.InputSignal<BooleanInput>;
    /** Right icon definition */
    readonly rightIcon: _angular_core.WritableSignal<IconDefinition>;
    /** Sets the right custom icon */
    set _rightCustomIcon(v: string);
    /** Right custom icon class string */
    readonly rightCustomIcon: _angular_core.WritableSignal<string>;
    /** Left icon definition */
    readonly leftIcon: _angular_core.WritableSignal<IconDefinition>;
    /** Left custom icon class string */
    readonly leftCustomIcon: _angular_core.ModelSignal<string>;
    /** Text to display on the button */
    readonly text: _angular_core.InputSignal<string>;
    /** Manually set validity state */
    readonly valid: _angular_core.InputSignal<boolean>;
    /** Displays button in mini size when true */
    readonly mini: _angular_core.InputSignal<boolean>;
    /** Behavior when form is invalid: disable button or show warning */
    readonly onFormInvalid: _angular_core.InputSignal<"disable" | "warn">;
    /** Event emitted when button is clicked */
    readonly mclick: _angular_core.OutputEmitterRef<any>;
    /** Reference to the inner text element */
    innerText: ElementRef<HTMLSpanElement>;
    /** Icon to show when button is locked/disabled */
    readonly lockedIcon: _angular_core.WritableSignal<IconDefinition>;
    /** Internal text storage */
    protected readonly _text: _angular_core.WritableSignal<string>;
    /** Controls the disabled state of the button */
    readonly disabled: _angular_core.ModelSignal<boolean>;
    /** Computed text to display based on input and internal state */
    readonly computedText: _angular_core.Signal<string>;
    /** Determines if a left icon should be displayed */
    protected readonly isLeftIcon: _angular_core.Signal<string | IconDefinition>;
    /** Determines if a right icon should be displayed */
    protected readonly isRightIcon: _angular_core.Signal<string | IconDefinition>;
    constructor();
    ngAfterViewChecked(): void;
    /**
     * Initializes the button with default settings if needed
     */
    ngOnInit(): void;
    /**
     * Sets the loading state of the button
     * @param val True to show loading indicator, false to hide
     */
    setLoader(val: boolean): void;
    /**
     * Gets text description of the button for logging purposes
     */
    get extractText(): string;
    /**
     * Handles button click events
     * @param $event The click event
     */
    click($event: any): void;
    /**
     * Computed property that determines if the button should be disabled
     * based on various conditions including form validity
     */
    readonly isDisabled: _angular_core.Signal<boolean>;
    /**
     * Disables the button
     */
    disable(): void;
    /**
     * Enables the button
     */
    enable(): void;
    /**
     * Validates forms associated with a button when the button is disabled
     * Marks all form controls as touched to display validation errors
     * @param btn - The button component associated with forms
     */
    checkForm(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BtnComponent, "app-btn", never, { "formSchema": { "alias": "formSchema"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "centerBtn": { "alias": "centerBtn"; "required": false; "isSignal": true; }; "danger": { "alias": "danger"; "required": false; "isSignal": true; }; "warning": { "alias": "warning"; "required": false; "isSignal": true; }; "verbose": { "alias": "verbose"; "required": false; "isSignal": true; }; "translatorOptions": { "alias": "translatorOptions"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "_icon": { "alias": "icon"; "required": false; }; "_rightIcon": { "alias": "rightIcon"; "required": false; }; "_leftIcon": { "alias": "leftIcon"; "required": false; }; "_type": { "alias": "type"; "required": false; }; "_group": { "alias": "group"; "required": false; }; "actionType": { "alias": "actionType"; "required": false; "isSignal": true; }; "animate": { "alias": "animate"; "required": false; "isSignal": true; }; "excludeLogging": { "alias": "excludeLogging"; "required": false; }; "loggingValue": { "alias": "loggingValue"; "required": false; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "customIcon": { "alias": "customIcon"; "required": false; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "forms": { "alias": "forms"; "required": false; "isSignal": true; }; "help": { "alias": "help"; "required": false; "isSignal": true; }; "helpShowDelay": { "alias": "helpShowDelay"; "required": false; "isSignal": true; }; "_iconBtn": { "alias": "iconBtn"; "required": false; }; "mclass": { "alias": "mclass"; "required": false; "isSignal": true; }; "showHelpIcon": { "alias": "showHelpIcon"; "required": false; "isSignal": true; }; "_rightCustomIcon": { "alias": "rightCustomIcon"; "required": false; }; "leftCustomIcon": { "alias": "leftCustomIcon"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; "isSignal": true; }; "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "onFormInvalid": { "alias": "onFormInvalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "loading": "loadingChange"; "leftCustomIcon": "leftCustomIconChange"; "mclick": "mclick"; "disabled": "disabledChange"; }, never, ["*"], true, never>;
    static ngAcceptInputType_excludeLogging: string | boolean | undefined;
    static ngAcceptInputType__iconBtn: string | boolean | undefined;
}
/**
 * Interface for form state tracking
 */
interface IFormState {
    valid?: boolean;
}

/**
 * Large button component that extends the base BtnComponent with additional functionality.
 * Provides support for routing, sub-items, and value handling.
 */
declare class BtnLgComponent extends BtnComponent {
    /**
     * Configures how query parameters are handled for navigation.
     * @see QueryParamsHandling from Angular Router
     */
    readonly queryParamsHandling: _angular_core.InputSignal<QueryParamsHandling>;
    /**
     * The route to navigate to when the button is clicked.
     */
    readonly route: _angular_core.InputSignal<string>;
    /**
     * The value associated with this button.
     */
    readonly value: _angular_core.InputSignal<string | number>;
    /**
     * Array of sub-items with labels and values to be displayed within the button.
     */
    readonly subs: _angular_core.InputSignal<{
        label: string;
        value: any;
    }[]>;
    /**
     * Additional text to be displayed as a sub-element of the button.
     */
    readonly subText: _angular_core.InputSignal<string>;
    /**
     * Additional value to be displayed as a sub-element of the button.
     */
    readonly subValue: _angular_core.InputSignal<string | number>;
    /**
     * Output event emitter for button click events.
     * Overrides the base component's mclick.
     */
    readonly mclick: _angular_core.OutputEmitterRef<void>;
    /**
     * Computed property that determines if the button has sub-items.
     * @returns True if the button has sub-items, false otherwise.
     */
    readonly hasSubs: _angular_core.Signal<boolean>;
    /**
     * Handles button click events.
     * Emits the click event and logs it unless logging is excluded.
     * @param $event The click event object
     */
    click($event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnLgComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BtnLgComponent, "app-btn-lg,btn-lg", never, { "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; "isSignal": true; }; "route": { "alias": "route"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "subs": { "alias": "subs"; "required": false; "isSignal": true; }; "subText": { "alias": "subText"; "required": false; "isSignal": true; }; "subValue": { "alias": "subValue"; "required": false; "isSignal": true; }; }, { "mclick": "mclick"; }, never, never, true, never>;
}

/**
 * Button component that acts as a link, extending the base BtnComponent.
 * Can be used for navigation with RouterLink or as an email link.
 */
declare class BtnLinkComponent extends BtnComponent {
    /** Defines how the router handles query parameters for the link. */
    mqueryParamsHandling: _angular_core.InputSignal<QueryParamsHandling>;
    /** The route path for navigation. */
    route: _angular_core.InputSignal<string>;
    /** Optional parameters to be passed with the route. */
    params: _angular_core.InputSignal<{
        [x: string]: string | number | boolean;
    }>;
    /** Email address for mailto links. */
    emailTo: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnLinkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BtnLinkComponent, "btn-link", never, { "mqueryParamsHandling": { "alias": "mqueryParamsHandling"; "required": false; "isSignal": true; }; "route": { "alias": "route"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "emailTo": { "alias": "emailTo"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const BtnModule: readonly [typeof BtnComponent, typeof BtnLgComponent];

/**
 * Directive that marks a template as a modal body content.
 *
 * This directive is used to identify and reference template content
 * that should be rendered within the body section of a modal dialog.
 *
 * @example
 * ```html
 * <ng-template modalBody>
 *   <p>This content will be rendered in the modal body.</p>
 * </ng-template>
 * ```
 */
declare class ModalBodyDirective {
    templateRef: TemplateRef<unknown>;
    /**
     * Creates an instance of ModalBodyDirective.
     *
     * @param templateRef - Reference to the template that this directive is attached to.
     *                      This template contains the content to be rendered in the modal body.
     */
    constructor(templateRef: TemplateRef<unknown>);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalBodyDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalBodyDirective, "[modalBody]", never, {}, {}, never, never, true, never>;
}

/**
 * Directive that identifies a template as a modal footer.
 *
 * Use this directive to mark a template that should be rendered
 * in the footer section of a modal dialog.
 *
 * @example
 * ```html
 * <ng-template modalFooter>
 *   <button type="button" class="btn btn-secondary" (click)="close()">Close</button>
 *   <button type="button" class="btn btn-primary" (click)="save()">Save</button>
 * </ng-template>
 * ```
 */
declare class ModalFooterDirective {
    templateRef: TemplateRef<unknown>;
    /**
     * Creates an instance of ModalFooterDirective.
     *
     * @param templateRef - Reference to the template that this directive is attached to
     */
    constructor(templateRef: TemplateRef<unknown>);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFooterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalFooterDirective, "[modalFooter]", never, {}, {}, never, never, true, never>;
}

/**
 * Configuration interface for opening a modal dialog
 *
 * This interface provides options for configuring how a modal dialog should be opened,
 * including the ability to pass a pointer event (for positioning relative to click)
 * and Angular Material dialog configuration options.
 */
interface IModalOpenConfig {
    /**
     * Optional pointer event that triggered the modal opening
     * Can be used for positioning the modal relative to where the user clicked
     */
    pointerEvent?: PointerEvent;
    /**
     * Optional Angular Material dialog configuration
     * Allows customizing dialog behavior, appearance, and positioning
     * @see {@link MatDialogConfig} for available configuration options
     */
    matDialogConfig?: MatDialogConfig;
}

/**
 * A reusable modal component built on top of Angular Material Dialog.
 * Provides customizable header, body, and footer sections with support for fullscreen mode.
 *
 * @template T The type of data returned when the modal is closed
 *
 * @example
 * Basic usage:
 * ```html
 * <modal-comp #myModal [header]="'My Modal Title'">
 *   <ng-template modalBody>
 *     <p>This is the modal content</p>
 *   </ng-template>
 *   <ng-template modalFooter>
 *     <button (click)="myModal.close()">Close</button>
 *     <button (click)="myModal.close(true)">Save</button>
 *   </ng-template>
 * </modal-comp>
 * ```
 *
 * @example
 * Opening programmatically:
 * ```typescript
 * @Component({...})
 * export class MyComponent {
 *   @ViewChild('myModal') modal: ModalComponent;
 *
 *   openModal() {
 *     this.modal.open();
 *   }
 *
 *   handleModalClose(result: any) {
 *     console.log('Modal closed with result:', result);
 *   }
 * }
 * ```
 *
 * @example
 * Using with lazy-loaded templates:
 * ```html
 * <modal-comp #lazyModal
 *   [header]="'Lazy Modal'"
 *   [bodyTemplateRef]="bodyTemplate"
 *   [footerTemplateRef]="footerTemplate">
 * </modal-comp>
 *
 * <ng-template #bodyTemplate>
 *   <p>This body content is lazy-loaded</p>
 * </ng-template>
 *
 * <ng-template #footerTemplate>
 *   <button (click)="lazyModal.close()">Close</button>
 * </ng-template>
 * ```
 */
declare class ModalComponent<T = any> implements OnInit {
    uS: UtilityService;
    cdr: ChangeDetectorRef;
    /** Reference to the modal template */
    protected readonly tempRef: _angular_core.Signal<TemplateRef<any>>;
    /** Modal header text */
    readonly header: _angular_core.ModelSignal<string>;
    /**
     * Template reference for the modal body when using lazy loading
     */
    bodyTemplateRef: TemplateRef<any>;
    /**
     * Template reference for the modal footer when using lazy loading
     */
    footerTemplateRef: TemplateRef<any>;
    /**
     * Controls the visibility of the modal header
     * @default true
     */
    readonly showHeader: _angular_core.ModelSignal<boolean>;
    /** Emits when mouse leaves the modal */
    readonly mouseLeft: _angular_core.OutputEmitterRef<MouseEvent>;
    /** Controls the loading state of the modal */
    readonly loading: _angular_core.ModelSignal<boolean>;
    /** Tracks whether the modal is in fullscreen mode */
    protected readonly isFullscreen: _angular_core.WritableSignal<boolean>;
    /**
     * Sets the fullscreen mode of the modal
     * When enabled, automatically hides header and footer
     */
    set _isFullscreen(v: boolean);
    /**
     * Controls the visibility of the modal footer
     * @default true
     */
    readonly showFooter: _angular_core.ModelSignal<boolean>;
    /** Width of the modal dialog */
    width: string;
    /** Minimum width of the modal dialog */
    minWidth: string;
    /** Height of the modal dialog */
    height: string;
    /** Maximum height of the modal dialog */
    maxHeight: string;
    /** Icon to display in the modal */
    icon: IconType;
    /** Data to be passed to the modal */
    data: {
        [x: string]: any;
    };
    /** Whether clicking outside the modal should close it */
    disableClose: boolean;
    /** Whether to show a backdrop behind the modal */
    hasBackdrop: boolean;
    /** Reference to the Angular Material dialog */
    protected readonly dialogRef: _angular_core.WritableSignal<MatDialogRef<any, any>>;
    /** Emits when the modal is opened */
    modalOpen: EventEmitter<boolean>;
    /** Emits when the modal is closed with the result data */
    readonly modalClose: _angular_core.OutputEmitterRef<false | T>;
    /** Tracks whether the modal is currently open */
    protected readonly isOpened: _angular_core.WritableSignal<boolean>;
    /** Tracks whether the modal content is loaded */
    protected readonly isLoaded: _angular_core.WritableSignal<boolean>;
    /** Base configuration for the Material dialog */
    readonly baseConfig: _angular_core.InputSignal<MatDialogConfig<any>>;
    /** Template for the modal body content */
    bodyTemplate: _angular_core.Signal<ModalBodyDirective>;
    /** Template for the modal footer content */
    footerTemplate: _angular_core.Signal<ModalFooterDirective>;
    /**
     * @param uS Utility service for dialog operations
     * @param cdr Change detector reference for manual change detection
     */
    constructor(uS: UtilityService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    /**
     * Opens the modal dialog
     * @param config Optional configuration for opening the modal
     * @returns void
     */
    open(config?: IModalOpenConfig): void;
    /**
     * Closes the modal dialog
     * @param value Optional value to return when the modal closes
     * @returns void
     */
    close(value?: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent<any>, "modal-comp", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "bodyTemplateRef": { "alias": "bodyTemplateRef"; "required": false; }; "footerTemplateRef": { "alias": "footerTemplateRef"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "_isFullscreen": { "alias": "isFullscreen"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "height": { "alias": "height"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "data": { "alias": "data"; "required": false; }; "disableClose": { "alias": "disableClose"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "baseConfig": { "alias": "baseConfig"; "required": false; "isSignal": true; }; }, { "header": "headerChange"; "showHeader": "showHeaderChange"; "mouseLeft": "mouseLeft"; "loading": "loadingChange"; "showFooter": "showFooterChange"; "modalOpen": "modalOpen"; "modalClose": "modalClose"; }, ["bodyTemplate", "footerTemplate"], ["[body]", "[footer]"], true, never>;
}

declare class DetailsBtnComponent<FG extends {
    [k in keyof FG]: AbstractControl<any, any>;
}> {
    cdr: ChangeDetectorRef;
    readonly form: _angular_core.InputSignal<FormGroup<FG>>;
    readonly fields: _angular_core.InputSignal<(keyof FG)[]>;
    readonly modal: _angular_core.InputSignal<ModalComponent<any>>;
    constructor(cdr: ChangeDetectorRef);
    readonly hasDetails: _angular_core.Signal<boolean>;
    readonly type: _angular_core.Signal<"primary" | "secondary">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DetailsBtnComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DetailsBtnComponent<any>, "details-btn", never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Card component that provides a styled container with optional header and customizable appearance.
 * Used to display content in a card-like UI element with configurable styling options.
 */
declare class CardComponent {
    /** Text to display in the card header */
    header: _angular_core.InputSignal<string>;
    /** Controls whether the card has a dark background. Defaults to true */
    isDarkBg: _angular_core.InputSignal<boolean>;
    /** Sets the height of the card content area */
    contentHeight: _angular_core.InputSignal<string>;
    /** Additional CSS classes to apply to the card container. Defaults to 'mt-3' */
    containerClass: _angular_core.InputSignal<string>;
    /** CSS classes to apply to the card header. Defaults to 'bg-primary' */
    headerClass: _angular_core.InputSignal<string>;
    /** Template reference for custom action buttons to display in the card */
    actionBtnTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "app-card", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "isDarkBg": { "alias": "isDarkBg"; "required": false; "isSignal": true; }; "contentHeight": { "alias": "contentHeight"; "required": false; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": false; "isSignal": true; }; "headerClass": { "alias": "headerClass"; "required": false; "isSignal": true; }; "actionBtnTemplate": { "alias": "actionBtnTemplate"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * A reusable confirmation dialog component that presents a question to the user
 * with Yes/No options.
 *
 * This component is designed to be used with Angular Material's dialog system.
 */
declare class ConfirmDialogComponent implements OnInit {
    text: string;
    dialogRef: MatDialogRef<ConfirmDialogComponent>;
    /**
     * Creates an instance of ConfirmDialogComponent.
     *
     * @param text - The message text to display in the confirmation dialog
     * @param dialogRef - Reference to the dialog opened via the MatDialog service
     */
    constructor(text: string, dialogRef: MatDialogRef<ConfirmDialogComponent>);
    /**
     * Lifecycle hook that is called after data-bound properties are initialized
     */
    ngOnInit(): void;
    /**
     * Handles the user clicking the "Yes" button
     * Closes the dialog and returns true to the caller
     */
    yes(): void;
    /**
     * Handles the user clicking the "No" button
     * Closes the dialog and returns false to the caller
     */
    no(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDialogComponent, "app-confirm-dialog", never, {}, {}, never, never, true, never>;
}

declare class ETSConfirmDialogService {
    dialog: MatDialog;
    constructor(dialog: MatDialog);
    /**
     * Shows the confirmation dialog box
     * @param text
     * @returns boolean promise
     */
    confirm(text: string): Promise<boolean>;
    /**
     * Shows the confirmation dialog box
     * @param text
     * @returns dialogbox observable
     */
    confirm$(text: string): _angular_material_dialog.MatDialogRef<ConfirmDialogComponent, any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSConfirmDialogService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSConfirmDialogService>;
}

/**
 * @deprecated The method should not be used. Use app-btn instead
 */
declare class ButtonComponent {
    readonly buttonType: _angular_core.InputSignal<string>;
    readonly text: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly faEye: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faPlus: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faClone: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faSearch: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faCheck: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faFile: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faSave: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faEdit: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faUpload: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faPlay: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faPen: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faTrash: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faArrowRight: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faArrowLeft: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faHistory: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faSlidersH: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    readonly faCogs: _angular_core.WritableSignal<_fortawesome_fontawesome_common_types.IconDefinition>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "app-button", never, { "buttonType": { "alias": "buttonType"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type FileNameFormat = 'NON_POLICY_DOCUMENT' | 'POLICY_DOCUMENT' | 'POLICY_DOCUMENT_WITH_SUFFIX' | 'POLICY_DOCUMENT_SUFFIX';

declare class DocumentsNameDisplayComponent implements OnInit {
    files: File[];
    fileNameFormat: FileNameFormat;
    valid: EventEmitter<boolean>;
    error: EventEmitter<any>;
    fileFormats: {
        NON_POLICY_DOCUMENT: string;
        POLICY_DOCUMENT: string;
        POLICY_DOCUMENT_WITH_SUFFIX: string;
    };
    fileNames: any[];
    errors: string[];
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    displayFileNames(files: any): void;
    parseFileName(name: any): any;
    getPolicyDocumentParams(name: any): {
        refCat: any;
        policyNo: any;
        policyCode: any;
        docSubCat: any;
        title: any;
    };
    getPolicyDocumentWithSuffixParams(name: any): {
        refCat: any;
        policyNo: any;
        policyCode: any;
        policyNoSuffix: any;
        docSubCat: any;
        title: any;
    };
    getNonPolicyDocumentParams(name: any): {
        refCat: any;
        refNo: any;
        docSubCat: any;
        title: any;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DocumentsNameDisplayComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DocumentsNameDisplayComponent, "app-documents-name-display", never, { "files": { "alias": "files"; "required": false; }; "fileNameFormat": { "alias": "fileNameFormat"; "required": false; }; }, { "valid": "valid"; "error": "error"; }, never, never, true, never>;
}

/**
 * Component that displays text with optional editing capabilities.
 * Allows for formatting, routing, and various display options.
 */
declare class EditableTextCaseComponent implements OnInit {
    /** Function to call instead of enabling edit mode */
    action: any;
    /** Whether to apply color styling to the label */
    coloredLbl: boolean;
    /** Whether to apply color styling to the value */
    coloredVal: boolean;
    /** Form object for binding */
    form: any;
    /** Function to format the displayed value */
    formatter: (item: any) => string | Promise<string> | Observable<string>;
    /** Hint text to display (using Angular's signal-based input) */
    readonly hint: _angular_core.InputSignal<string>;
    /** Hint text to display for the value */
    valueHint: string;
    /** Label text to display */
    label: string;
    /** Whether to use light styling */
    light: boolean;
    /** Whether to use mini styling */
    mini: boolean;
    /** Name identifier for the component */
    name: string;
    /** Route to navigate to when clicked */
    route: string;
    /** Function that returns a route to navigate to */
    routeFunc: (item: any) => Promise<string> | Observable<string>;
    /** Whether to show editing controls */
    showEditing: boolean;
    /** Whether to stack label and value vertically */
    stacked: boolean;
    /** Input type for editing mode */
    type: InputType;
    /** Value to display */
    value: any;
    /** Whether to wrap the label text */
    wrapLabel: boolean;
    /** Whether the component is currently in edit mode */
    editing: boolean;
    constructor();
    /**
     * Lifecycle hook that is called after data-bound properties are initialized
     */
    ngOnInit(): void;
    /**
     * Exits edit mode
     */
    reset(): void;
    /**
     * Enters edit mode or calls the action function if provided
     */
    unreset(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditableTextCaseComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditableTextCaseComponent, "app-editable-text-case", never, { "action": { "alias": "action"; "required": false; }; "coloredLbl": { "alias": "coloredLbl"; "required": false; }; "coloredVal": { "alias": "coloredVal"; "required": false; }; "form": { "alias": "form"; "required": false; }; "formatter": { "alias": "formatter"; "required": false; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "valueHint": { "alias": "valueHint"; "required": false; }; "label": { "alias": "label"; "required": false; }; "light": { "alias": "light"; "required": false; }; "mini": { "alias": "mini"; "required": false; }; "name": { "alias": "name"; "required": false; }; "route": { "alias": "route"; "required": false; }; "routeFunc": { "alias": "routeFunc"; "required": false; }; "showEditing": { "alias": "showEditing"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "wrapLabel": { "alias": "wrapLabel"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Service for handling table-related operations and formatting
 * Provides utilities for column management, formatting, and CSV export
 */
declare class TableService {
    /**
     * Map of general properties to apply to columns by field name
     * If a value is provided in the columns schema, it is ignored.
     */
    generalColumnPropMap: {
        [field: string]: Partial<TableCol>;
    };
    constructor();
    /**
     * Formats a key value to HTML with color coding
     * @param key - The key to format
     * @param codes - Array of key-value pairs mapping keys to color values
     * @returns HTML string with appropriate color class
     */
    formatToColours: (key: any, codes?: IKVP[]) => string;
    /**
     * Extracts field names from column definitions and adds special columns
     * @param arr - Array of column definitions
     * @param hasOptions - Whether to include an options column
     * @param useSelection - Whether to include selection checkboxes
     * @param placeSelectionAtRight - Whether to place selection checkboxes at the end (true) or beginning (false)
     * @param isExpandable - Whether to include an expand column
     * @returns Array of field names
     */
    getRawFields(arr: TableCol[], hasOptions: boolean, useSelection?: boolean, placeSelectionAtRight?: boolean, // the parameter is to support setting the selection checkboxes as the last item instead of the first
    isExpandable?: boolean): string[];
    /**
     * Global formatter for table columns
     * @param columns - Array of column definitions
     * @returns Formatted array of column definitions
     * @template TRow - Type of the row data
     */
    globalColumnsFormatter: <TRow>(columns: TableCol<TRow>[]) => TableCol<TRow>[];
    /**
     * Worker function to convert array data to CSV and trigger download
     * @param array - Array of data to convert
     * @param filename - Name of the file to download
     * @param columns - Optional array of column names to include
     * @param showHeader - Whether to include header row
     * @returns Promise that resolves when the CSV has been generated and download triggered
     */
    arrayToCSVWorker: (array: any[], filename: string, columns?: string[], showHeader?: boolean) => Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TableService>;
}

/**
 * Service responsible for managing form generator configuration.
 * Provides functionality to control validation message display behavior.
 */
declare class FormGeneratorService {
    /**
     * Internal configuration storage for form generator settings
     * @private
     */
    private _config;
    /**
     * Creates an instance of FormGeneratorService.
     * Initializes with default configuration.
     */
    constructor();
    /**
     * Gets the current form generator configuration.
     * @returns The current configuration object.
     */
    get config(): IFormGeneratorConfig;
    /**
     * Sets the form generator configuration.
     * @param value - The configuration object to set.
     */
    set config(value: IFormGeneratorConfig);
    /**
     * Controls whether validation messages should be shown by default.
     * @param state - Whether to show validation messages by default. Defaults to true.
     * @returns void
     */
    showValidationMessagesByDefault(state?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormGeneratorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FormGeneratorService>;
}
/**
 * Configuration interface for the form generator.
 */
interface IFormGeneratorConfig {
    /**
     * Determines whether validation messages should be displayed by default.
     * When true, validation messages will be shown automatically.
     */
    showValidationMessagesByDefault?: boolean;
}

/**
 * Base component for generating dynamic forms
 *
 * @template TFormGroup - Type representing the form group structure
 * @template TBaseFormSchema - Type representing the schema for form fields
 */
declare abstract class BaseFormGenerator<TFormGroup extends IObjectLiteral, TBaseFormSchema extends {
    field?: any;
    label?: string;
    _id?: string;
    ignore?: boolean;
} = any> {
    readonly tableService: TableService;
    /** Internal signal for form schema map */
    protected _formSchemaMap: _angular_core.WritableSignal<{
        [field: string]: TBaseFormSchema;
    }>;
    /** Computed value for form schema map */
    protected formSchemaMap: _angular_core.Signal<{
        [field: string]: TBaseFormSchema;
    }>;
    /**
     * Computed array of form schemas with optional custom label handling
     */
    readonly formSchema: _angular_core.Signal<TBaseFormSchema[]>;
    /** Map of subscriptions by field name */
    subs: {
        [fieldName: string]: Subscription;
    };
    /** Enable debug mode */
    readonly debug: _angular_core.InputSignal<boolean>;
    /** Custom templates for form fields */
    readonly customTemplates: _angular_core.InputSignal<{ [k in keyof TFormGroup]?: TemplateRef<any>; }>;
    utilityService: UtilityService<any>;
    destroyRef: DestroyRef;
    cdr: ChangeDetectorRef;
    /** Toggle for using custom labels */
    readonly useCustomLabels: _angular_core.ModelSignal<boolean>;
    /**
     * Constructor that sets up automatic cleanup when component is destroyed
     * by registering the onDestroy method with Angular's DestroyRef
     */
    constructor();
    /**
     * Cleanup method called when component is destroyed
     */
    onDestroy(): void;
    /**
     * Sets the form schemas
     *
     * @param schemas - Array of form field schemas to set
     */
    protected _setFormSchemas(schemas: TBaseFormSchema[]): void;
    /**
     * Updates a specific form schema field
     *
     * @param field - Field name to update
     * @param scheme - Partial schema to merge with existing schema
     */
    protected _updateFormSchema(field: string, scheme: Partial<TBaseFormSchema>): void;
    /**
     * Updates all form schemas using a mapping function
     *
     * @param map - Function to transform each form field schema
     * @returns The updated form schema array
     */
    protected _updateAllFormSchema(map: (formField: TBaseFormSchema) => TBaseFormSchema): TBaseFormSchema[];
    /**
     * Removes a form schema field
     *
     * @param field - Field name to remove
     */
    protected _removeFormSchema(field: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseFormGenerator<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseFormGenerator<any, any>, "ng-component", never, { "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "customTemplates": { "alias": "customTemplates"; "required": false; "isSignal": true; }; "useCustomLabels": { "alias": "useCustomLabels"; "required": false; "isSignal": true; }; }, { "useCustomLabels": "useCustomLabelsChange"; }, never, never, false, never>;
}

declare class InfoDialogService {
    dialog: MatDialog;
    overrideDialogConfig: MatDialogConfig;
    errorReporterService: ErrorReporterService;
    constructor(dialog: MatDialog);
    info: (text: string | unknown, status?: 1 | 0 | 2 | 3, heading?: string, btns?: IInfoDialogBtn[], disableClose?: boolean) => Promise<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoDialogService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InfoDialogService>;
}

/**
 * Form Generator Component
 *
 * A dynamic form generation component that creates and manages forms based on a schema.
 * The form should be set before the formSchema.
 *
 * @template TFormGroup The type of the form group
 * @template TFormSchema The type of the form schema
 */
declare class FormGeneratorComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
}, TFormSchema extends IFormSchema<TFormGroup> = IFormSchema<TFormGroup>> extends BaseFormGenerator<TFormGroup, TFormSchema> {
    infoDialogService: InfoDialogService;
    /** Determines which field to use as the key - 'field' or 'label' */
    keyField: 'field' | 'label';
    /** Whether to preset value for single option */
    readonly presetValueForSingleOption: _angular_core.InputSignal<boolean>;
    /** Whether the form is in create mode */
    readonly isCreate: _angular_core.InputSignal<boolean>;
    /** Whether to submit the form when Enter key is pressed */
    readonly submitOnEnterKey: _angular_core.InputSignal<boolean>;
    /** Reference to the form element */
    readonly formTagRef: _angular_core.Signal<ElementRef<HTMLFormElement>>;
    /** Emitted just before calling the save function */
    onSubmit: EventEmitter<any>;
    /** Emitted when form values change */
    mchange: EventEmitter<any>;
    /** Emitted after receiving feedback from the submit function */
    saved: EventEmitter<any>;
    /** Function to call when submitting the form */
    submitFunc: (value: any) => Promise<any>;
    /** Text to display on the submit button */
    readonly submitBtnText: _angular_core.InputSignal<string>;
    /** Custom template for the submit button */
    readonly submitBtnTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Text to display after successful submission */
    readonly submitSuccessText: _angular_core.InputSignal<string>;
    readonly showSubmitSuccessText: _angular_core.InputSignal<boolean>;
    /** Whether to show the submit button */
    readonly showSubmitBtn: _angular_core.InputSignal<boolean>;
    /** Grid style for default view */
    readonly gridStyle: _angular_core.InputSignal<number | "auto">;
    /** Grid style for medium screens */
    readonly gridMDStyle: _angular_core.InputSignal<number | "auto">;
    /** Grid style for large screens */
    readonly gridLGStyle: _angular_core.InputSignal<number | "auto">;
    /** Grid style for extra-extra-large screens */
    readonly gridXXLStyle: _angular_core.InputSignal<number | "auto">;
    /** CSS class for the form grid */
    readonly formGridClass: _angular_core.InputSignal<string>;
    /** Whether to use a loader */
    readonly useLoader: _angular_core.InputSignal<boolean>;
    /** Whether the form is loading */
    readonly loading: _angular_core.InputSignal<boolean>;
    /** Internal loading state */
    readonly _loading: _angular_core.WritableSignal<boolean>;
    /** Computed loading state based on useLoader and loading inputs */
    readonly computedLoading: _angular_core.Signal<boolean>;
    /** Reference to the submit button component */
    readonly submitBtnRef: _angular_core.Signal<BtnComponent>;
    /** The form group */
    readonly form: _angular_core.ModelSignal<FormGroup<TFormGroup>>;
    /** Observable of the form */
    readonly form$: Observable<FormGroup<TFormGroup>>;
    /** Observable of the form value */
    readonly formValue$: Observable<{} | {}>;
    /** Signal of the form value */
    readonly formValue: _angular_core.Signal<{} | {}>;
    /** Response from form submission */
    submissionResponse: any;
    /**
     * Sets the form schema
     * @param v The form schema
     */
    set _formSchema(v: TFormSchema[] | IFormSchema<any>[]);
    /**
     * Sets the form schema without requiring a pre-existing form
     * @param v The form schema
     */
    set _formSchemaNoForm(v: TFormSchema[]);
    /**
     * Sets whether the form is in show mode (disabled)
     * @param v Whether the form is in show mode
     */
    set _isShow(v: boolean);
    /** Map of options for form fields */
    readonly optionsMap: _angular_core.WritableSignal<IFormOptions>;
    /** Computed form schema with hidden fields filtered out */
    readonly computedFormSchema: _angular_core.Signal<IFormSchema<TFormGroup>[]>;
    /** Form generator service */
    formService: FormGeneratorService;
    constructor();
    /**
     * Initialize the form generator with a schema
     * @param schema The form schema
     */
    init(schema: TFormSchema[]): void;
    /**
     * Handle a form scheme by setting up its properties and subscriptions
     * @param scheme The form scheme to handle
     */
    handleFormScheme(scheme: TFormSchema): void;
    /**
     * Handle options fetched for a form scheme
     * @param scheme The form scheme
     * @param options$ Observable of options
     */
    protected handleOptionsFetched(scheme: TFormSchema, options$: Observable<any[]>): void;
    /**
     * Detach a form scheme by unsubscribing from its subscriptions
     * @param fieldName The field name of the form scheme
     */
    detachFormScheme(fieldName?: keyof TFormGroup): void;
    /**
     * Emit the form value change event
     */
    protected mchangeEmitter(): void;
    /**
     * Get a form scheme by field name
     * @param fieldName The field name
     * @returns The form scheme
     */
    getFormScheme: (fieldName: keyof TFormGroup) => TFormSchema;
    /**
     * Add a form scheme to the form schema
     * @param formScheme The form scheme to add
     */
    addToFormSchema(formScheme: TFormSchema): void;
    /**
     * Update a form scheme in the form schema
     * @param fieldName The field name
     * @param scheme The partial form scheme to update
     * @returns The updated form schema map
     */
    updateFormSchema(fieldName: keyof TFormGroup, scheme: Partial<TFormSchema>): void;
    /**
     * Update all form schemes in the form schema
     * @param map Function to map each form scheme
     * @returns The updated form schema
     */
    updateAllFormSchema(map: (formField: IFormSchema<TFormGroup>) => TFormSchema): TFormSchema[];
    /**
     * Remove a form scheme from the form schema
     * @param fieldName The field name
     */
    removeFromFormSchema(fieldName: keyof TFormGroup): void;
    /**
     * Set the selected option label for a form scheme
     * @param $event The event
     * @param scheme The form scheme
     */
    protected setOptionLabel($event: any, scheme: IFormSchema<TFormGroup>): void;
    /**
     * Submit the form
     * @param btn The submit button component
     */
    submit(btn?: BtnComponent): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormGeneratorComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormGeneratorComponent<any, any>, "form-generator", never, { "keyField": { "alias": "keyField"; "required": false; }; "presetValueForSingleOption": { "alias": "presetValueForSingleOption"; "required": false; "isSignal": true; }; "isCreate": { "alias": "isCreate"; "required": false; "isSignal": true; }; "submitOnEnterKey": { "alias": "submitOnEnterKey"; "required": false; "isSignal": true; }; "submitFunc": { "alias": "submitFunc"; "required": false; }; "submitBtnText": { "alias": "submitBtnText"; "required": false; "isSignal": true; }; "submitBtnTemplate": { "alias": "submitBtnTemplate"; "required": false; "isSignal": true; }; "submitSuccessText": { "alias": "submitSuccessText"; "required": false; "isSignal": true; }; "showSubmitSuccessText": { "alias": "showSubmitSuccessText"; "required": false; "isSignal": true; }; "showSubmitBtn": { "alias": "showSubmitBtn"; "required": false; "isSignal": true; }; "gridStyle": { "alias": "gridStyle"; "required": false; "isSignal": true; }; "gridMDStyle": { "alias": "gridMDStyle"; "required": false; "isSignal": true; }; "gridLGStyle": { "alias": "gridLGStyle"; "required": false; "isSignal": true; }; "gridXXLStyle": { "alias": "gridXXLStyle"; "required": false; "isSignal": true; }; "formGridClass": { "alias": "formGridClass"; "required": false; "isSignal": true; }; "useLoader": { "alias": "useLoader"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "_formSchema": { "alias": "formSchema"; "required": false; }; "_formSchemaNoForm": { "alias": "formSchemaNoForm"; "required": false; }; "_isShow": { "alias": "isShow"; "required": false; }; }, { "onSubmit": "onSubmit"; "mchange": "mchange"; "saved": "saved"; "form": "formChange"; }, never, never, true, never>;
}
/**
 * Interface for form schema configuration
 *
 * Defines the structure and behavior of a form field within the FormGeneratorComponent.
 *
 * @template TFormGroup - The type of the form group containing this field
 */
interface IFormSchema<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any> extends IBaseFormSchema<TFormGroup, FormGeneratorComponent<TFormGroup>, TFormGroup> {
    /** Child form schemas for nested form structures */
    children?: IFormSchema<TFormGroup>[];
    /** Type of label to display for options (e.g., 'default', 'checkbox', etc.) */
    labelType?: OptionLabelType;
    /** The form control field name in the form group */
    field: keyof TFormGroup;
    /** Subtype of the input (e.g., 'text', 'number', 'email', etc.) */
    subType?: InputSubType;
    /** Whether to preset the value for this field */
    presetValue?: boolean;
    /**
     * Custom template reference for rendering this form field
     *
     * Template variable model:
     * ```
     * {
     *    row: FormGroup<TFormGroup>;
     *    scheme: IFormSchema;
     * }
     * ```
     * ```
     */
    templateRef?: TemplateRef<any>;
    /** Buttons to display beside the input */
    btns?: IBtn[];
}
interface IFormSchema2<TStruct = any> extends IFormSchema<{
    [K in keyof TStruct]?: AbstractControl<any, any>;
}> {
}

/**
 * Interface extending IFormSchema for table input form configurations.
 * Provides additional properties specific to table input forms.
 *
 * @template TFormGroup - The type of form group this schema represents.
 *                        Must be an object with keys mapping to AbstractControl instances.
 */
interface ITableInputFormSchema<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any> extends IFormSchema<TFormGroup> {
    /**
     * Whether the column should be sticky (fixed position during scroll).
     */
    sticky?: boolean;
    /**
     * The width of the column, specified as a CSS value (e.g., '100px', '10%').
     */
    width?: string;
}
/**
 * Interface for table input button configuration
 * Extends the base button interface with table-specific action handling
 */
interface ITableInputBtn extends IBtn {
    /** Action to perform when the button is clicked */
    action?: (arg?: {
        index: number;
        form: FormGroup;
        btn: BtnComponent;
    }) => void;
}
/**
 * Interface for table search response data
 * @template T - The type of items in the response
 */
interface ITableSearchResp<T = any> {
    totalElements?: number;
    page?: {
        totalElements: number;
        content: T[];
    };
    content?: T[];
    total?: number;
}
/**
 * Interface for table search function
 * @template T - The type of items in the response
 */
interface ITableSearchFunc<T = any> {
    totalElements?: number;
    page?: {
        totalElements: number;
        content: T[];
    };
    content?: T[];
    total?: number;
}

/**
 * Component for exporting table data to CSV format.
 * Provides functionality to download table data with customizable columns and search functionality.
 */
declare class ExportTableComponent {
    /** The data array to be exported */
    readonly data: _angular_core.InputSignal<any[]>;
    /** Columns configuration for the table */
    readonly displayedColumns: _angular_core.InputSignal<TableCol<any>[]>;
    /** Function to fetch data when search is needed */
    readonly searchFunc: _angular_core.InputSignal<(data: any) => Observable<ITableSearchResp<any>>>;
    /** Raw search query parameters */
    readonly _searchQuery: _angular_core.InputSignal<{
        [x: string]: string | number | boolean;
    }>;
    /** Computed search query with pagination parameters removed */
    readonly searchQuery: _angular_core.Signal<IGetQuery>;
    /** Label for the exported file */
    readonly label: _angular_core.InputSignal<string>;
    /** Flag to enable debug mode */
    readonly debug: _angular_core.InputSignal<boolean>;
    /** Flag to disable the export functionality */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /** Loading state indicator */
    readonly loading: _angular_core.WritableSignal<boolean>;
    /** User activity service for tracking export actions */
    uaS: UserActivityService;
    /** Table service for CSV conversion */
    tableS: TableService;
    /** Utility service for fallback CSV conversion */
    uS: UtilityService<any>;
    /**
     * Filtered columns that are suitable for export (excludes button and input columns)
     * and removes formatter functions that aren't needed for export
     */
    readonly cdisplayedColumns: _angular_core.Signal<TableCol<any>[]>;
    /** Field names of the filtered columns for export */
    readonly cdisplayedColumnFieldNames: _angular_core.Signal<string[]>;
    /**
     * Downloads the table data as a CSV file
     *
     * @param data - Optional data array to export (defaults to component's data input)
     * @param label - Optional label for the CSV file (defaults to component's label input)
     * @returns Promise that resolves when the download is complete
     */
    downloadCSV(data?: any[], label?: string): Promise<void>;
    /**
     * Computed property that determines if the export functionality should be disabled
     * Returns true if explicitly disabled or if there are no columns to export
     */
    readonly disableExport: _angular_core.Signal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExportTableComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExportTableComponent, "app-export-table", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "searchFunc": { "alias": "searchFunc"; "required": false; "isSignal": true; }; "_searchQuery": { "alias": "searchQuery"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Component for handling file uploads with optional webcam integration.
 * Supports single or multiple file selection, custom file type filtering,
 * and webcam capture functionality.
 */
declare class FileUploadComponent implements OnInit {
    /** Help text to display with the upload component */
    help: string;
    /** Label text for the upload component */
    label: string;
    /** Width of the media display in pixels */
    mediaWidth: _angular_core.ModelSignal<number>;
    /** CSS class to apply to the component */
    class: _angular_core.InputSignal<string>;
    /** Whether to enable webcam functionality */
    useWebcam: _angular_core.InputSignal<boolean>;
    /**
     * Filename to use when capturing from webcam
     * Only useful if using the webcam option
     */
    readonly fileName: _angular_core.InputSignal<string>;
    /** Whether the upload functionality is disabled */
    disabled: boolean;
    /** Whether to allow multiple file selection */
    multiple: boolean;
    /** Whether to use the mini version of the component */
    mini: _angular_core.InputSignal<boolean>;
    /** Whether to use document modal for file selection */
    useDocumentModal: boolean;
    /** Whether to display the list of selected files */
    listFiles: _angular_core.InputSignal<boolean>;
    /** File types that are accepted by the upload component */
    accept: string;
    /**
     * Sets the accepted file types
     * @param v - String representing accepted file types or 'image' for common image formats
     */
    set _accept(v: string);
    /**
     * Currently selected file (for single file mode)
     */
    readonly file: _angular_core.ModelSignal<File>;
    /**
     * Event emitted when the selected file changes
     */
    readonly fileChange: _angular_core.OutputEmitterRef<File>;
    /**
     * Currently selected files (for multiple file mode)
     */
    readonly files: _angular_core.ModelSignal<File[]>;
    /**
     * Event emitted when the selected files change
     */
    readonly filesChange: _angular_core.OutputEmitterRef<File[]>;
    /** Utility service for common functions */
    uS: UtilityService<any>;
    constructor();
    ngOnInit(): void;
    /**
     * Returns whether the component is in single file mode
     * @returns True if multiple file selection is disabled
     */
    get isSingle(): boolean;
    /**
     * Accepts and processes the selected files
     * @param files - The files to be processed
     */
    protected acceptFiles(...files: File[]): void;
    /**
     * Emits file change events based on current selection
     */
    protected emitFiles(): void;
    /**
     * Handles file upload event from input element
     * @param event - The file input change event
     */
    onUpload(event: any): void;
    /**
     * Removes a file from the selection by index
     * @param index - The index of the file to remove
     */
    removeFile(index: number): void;
    /**
     * Removes all selected files
     */
    removeAllFiles(): void;
    /**
     * Opens the file selection dialog
     */
    openDialog(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploadComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploadComponent, "app-file-upload", never, { "help": { "alias": "help"; "required": false; }; "label": { "alias": "label"; "required": false; }; "mediaWidth": { "alias": "mediaWidth"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "useWebcam": { "alias": "useWebcam"; "required": false; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "useDocumentModal": { "alias": "useDocumentModal"; "required": false; }; "listFiles": { "alias": "listFiles"; "required": false; "isSignal": true; }; "_accept": { "alias": "accept"; "required": false; }; "file": { "alias": "file"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "mediaWidth": "mediaWidthChange"; "file": "fileChange"; "fileChange": "fileChange"; "files": "filesChange"; "filesChange": "filesChange"; }, never, never, true, never>;
}

/**
 * Angular pipe that adds a CSS class to form elements when they are invalid.
 *
 * This pipe observes form control status changes and emits a CSS class name
 * when the control(s) become invalid.
 */
declare class FormInvalidClassPipe implements OnDestroy, PipeTransform {
    /** Subscription to control status changes */
    sub: Subscription;
    /**
     * Cleans up subscriptions when the pipe is destroyed
     */
    ngOnDestroy(): void;
    /**
     * Transforms form control(s) into an Observable that emits CSS class names
     * based on the validity state of the control(s).
     *
     * @param controls - A single form control or an array of form controls to observe
     * @returns An Observable that emits 'custom-form-invalid' when any control is invalid, or an empty string otherwise
     */
    transform(controls: AbstractControl | AbstractControl[]): Observable<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormInvalidClassPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FormInvalidClassPipe, "formInvalidClass", true>;
}

/**
 * Angular pipe for translating text using the TranslationService.
 * This is the base translation pipe with standard loading behavior.
 */
declare class SDKTranslatePipe implements PipeTransform {
    tS: TranslationService;
    /**
     * Transforms the input text by translating it according to the provided configuration.
     * @param text - The text or number to be translated
     * @param config - Optional configuration for the translation process
     * @returns An Observable containing the translated string
     */
    transform(text: string | number, config?: ITranslatorConfig): Observable<string>;
    /**
     * @param tS - The translation service instance
     */
    constructor(tS: TranslationService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SDKTranslatePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SDKTranslatePipe, "appTranslate", true>;
}
/**
 * Translation pipe that doesn't display a loader during translation.
 * Extends the base SDKTranslatePipe but sets the noLoader flag to true.
 */
declare class SDKTranslateNoLoaderPipe extends SDKTranslatePipe implements PipeTransform {
    /**
     * Transforms the input text without showing a loader during translation.
     * @param text - The text, number or boolean to be translated
     * @param config - Optional configuration (noLoader and miniLoader are automatically set)
     * @returns An Observable containing the translated string
     */
    transform(text: string | number | boolean, config?: Omit<ITranslatorConfig, 'noLoader' | 'miniLoader'>): Observable<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SDKTranslateNoLoaderPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SDKTranslateNoLoaderPipe, "appTranslateNL", true>;
}
/**
 * Translation pipe that handles single translations.
 * Uses the singleHandle flag for optimized single translation handling.
 */
declare class SDKTranslateSinglePipe implements PipeTransform {
    tS: TranslationService;
    /**
     * Transforms the input text using single translation handling.
     * @param text - The text or number to be translated
     * @param config - Optional configuration (singleHandle is automatically set)
     * @returns An Observable containing the translated string
     */
    transform(text: string | number, config?: Omit<ITranslatorConfig, 'singleHandle'>): Observable<string>;
    /**
     * @param tS - The translation service instance
     */
    constructor(tS: TranslationService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SDKTranslateSinglePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SDKTranslateSinglePipe, "appTranslateSingle", true>;
}
/**
 * Translation pipe that handles single translations without displaying a loader.
 * Combines the behavior of SDKTranslateSinglePipe and SDKTranslateNoLoaderPipe.
 */
declare class SDKTranslateSingleNoLoaderPipe extends SDKTranslatePipe implements PipeTransform {
    /**
     * Transforms the input text using single translation handling without showing a loader.
     * @param text - The text, number or boolean to be translated
     * @param config - Optional configuration (noLoader, miniLoader, and singleHandle are automatically set)
     * @returns An Observable containing the translated string
     */
    transform(text: string | number | boolean, config?: Omit<ITranslatorConfig, 'noLoader' | 'miniLoader' | 'singleHandle'>): Observable<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SDKTranslateSingleNoLoaderPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SDKTranslateSingleNoLoaderPipe, "appTranslateSingleNL", true>;
}
/**
 * Pipe for reverse translation without displaying a loader.
 * Converts translated text back to its original form.
 */
declare class ReverseTranslateSingleNLPipe implements PipeTransform {
    tS: TranslationService;
    /**
     * @param tS - The translation service instance
     */
    constructor(tS: TranslationService);
    /**
     * Transforms the input text by reverse translating it.
     * @param text - The text, number or boolean to be reverse translated
     * @returns An Observable containing the reverse translated string
     */
    transform(text: string | number | boolean): Observable<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReverseTranslateSingleNLPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ReverseTranslateSingleNLPipe, "reverseTranslateSingleNL", true>;
}
/**
 * Angular module that bundles all translation pipes for easy import.
 * Import this module to make all translation pipes available in your application.
 */
declare class TranslatePipeModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslatePipeModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TranslatePipeModule, never, [typeof i1$1.CommonModule, typeof SDKTranslatePipe, typeof SDKTranslateNoLoaderPipe, typeof SDKTranslateSinglePipe, typeof SDKTranslateSingleNoLoaderPipe, typeof ReverseTranslateSingleNLPipe], [typeof SDKTranslatePipe, typeof SDKTranslateNoLoaderPipe, typeof SDKTranslateSinglePipe, typeof SDKTranslateSingleNoLoaderPipe, typeof ReverseTranslateSingleNLPipe]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TranslatePipeModule>;
}

/**
 * Splits an array into a smaller segment based on start and end indices
 */
declare class ArraySplitter implements PipeTransform {
    /**
     * Extracts a portion of an array between specified indices
     * @param arr The source array to split
     * @param arrLength The length of the array (not used in implementation)
     * @param startIndex The starting index (inclusive)
     * @param endIndex The ending index (exclusive)
     * @returns A new array containing elements from startIndex to endIndex
     */
    transform<T>(arr: T[], arrLength: number, startIndex: number, endIndex?: number): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArraySplitter, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ArraySplitter, "arraySplitter", true>;
}
/**
 * Transforms gender code to human-readable format
 */
declare class GenderPipe implements PipeTransform {
    /**
     * Converts gender code to full text representation
     * @param value Gender code ('M' or 'F')
     * @returns 'Male', 'Female', or the original value if not recognized
     */
    transform(value: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenderPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GenderPipe, "gender", true>;
}
/**
 * Rounds a number to the nearest integer
 */
declare class RoundPipe implements PipeTransform {
    /**
     * Rounds a number to the nearest integer using Math.round
     * @param value The number to round
     * @returns The rounded integer
     */
    transform(value: number): number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RoundPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<RoundPipe, "round", true>;
}
/**
 * Converts seconds to a formatted time string
 */
declare class SecondsToTimePipe implements PipeTransform {
    uS: UtilityService;
    /**
     * Converts seconds to a formatted time string (e.g., "2hrs 30min 45s")
     * @param value The number of seconds
     * @returns Formatted time string
     */
    transform(value: number): string;
    constructor(uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SecondsToTimePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SecondsToTimePipe, "secondsToTime", true>;
}
/**
 * Formats dates using the TimeAgo library
 */
declare class CustomDatePipe implements PipeTransform {
    datePipe: DatePipe;
    /**
     * Formats a date string using the TimeAgo library
     * @param date The date string to format
     * @param showTime Whether to show time (not used in implementation)
     * @returns Formatted relative time string (e.g., "2 hours ago")
     */
    transform(date: string, showTime?: boolean): string;
    /**
     * Alternative date formatting using Angular's DatePipe
     * @param date The date string to format
     * @param formatStr The format string to use
     * @returns Formatted date string
     */
    transform2(date: string, formatStr: string): string;
    constructor(datePipe: DatePipe);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CustomDatePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CustomDatePipe, "customDate", true>;
}
/**
 * Checks if an object has values in specified fields
 */
declare class HasValuePipe implements PipeTransform {
    /**
     * Checks if the fields in an object have any value
     * @param value The object to check
     * @param fieldsToCheckFor Optional array of field names to check
     * @returns True if any specified field has a value, or if the object is not empty
     */
    transform<T>(value: T, fieldsToCheckFor?: (keyof T)[]): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HasValuePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HasValuePipe, "hasValue", true>;
}
/**
 * Transforms a code into a title or description from a provided array
 */
declare class CodeTitleDescPipe implements PipeTransform {
    /**
     * Finds a matching code in an array and returns it with its description or title
     * @param codeTitleArray Array of objects containing code, title, and description
     * @param code The code to search for
     * @returns Formatted string with code and description/title, or empty string if not found
     */
    transform(codeTitleArray: {
        code: string;
        title?: string;
        description?: string;
    }[], code: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeTitleDescPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CodeTitleDescPipe, "codeTitleDesc", true>;
}
/**
 * Checks if a form has values in specified fields
 */
declare class HasFormValuePipe implements PipeTransform {
    /**
     * Checks if the fields in a formgroup object have any value
     * @param formGroup The form group to check
     * @param fieldsToCheckFor Optional array of field names to check
     * @param refresher Optional parameter to trigger pipe refresh
     * @returns True if any specified field has a value
     */
    transform<TValue, TForm extends {
        getRawValue: () => TValue;
    }>(formGroup: TForm, fieldsToCheckFor?: (keyof TValue)[], refresher?: any): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HasFormValuePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HasFormValuePipe, "hasFormValue", true>;
}
/**
 * Retrieves a label for a value from a list of options
 */
declare class GetValueLabel implements PipeTransform {
    /**
     * Converts a string into a Select option
     * @param value The value to search for in the options list
     * @param options The list of items to search in
     * @param labelField The field that holds the description field
     * @param valueField The field that holds the value field
     * @returns A concatenation of the value and description (value - description)
     */
    transform(value: string, options: any[], labelField?: string, valueField?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetValueLabel, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetValueLabel, "getValueLabel", true>;
}
/**
 * Formats a value using a provided formatter function
 */
declare class ValueFormatterPipe implements PipeTransform {
    /**
     * Applies a formatter function to a value
     * @param val The value to format
     * @param formatter Function that transforms the input value
     * @returns The formatted value or the original value if no formatter provided
     */
    transform<T, R = string>(val: T, formatter: (value: T) => R | Promise<R> | Observable<R>): Promise<T | R | Observable<R>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueFormatterPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ValueFormatterPipe, "valueFormatter", true>;
}
/**
 * Utility class for calling functions in templates
 */
declare class CFunctionCaller {
    /**
     * Calls a function in the template
     * @param func Function to be called
     * @param args
     * @returns
     */
    transform<T>(func: () => T): T;
    transform<T, P1>(func: (param1?: P1) => T, param1: P1): T;
    transform<T, P1, P2>(func: (param1?: P1, param2?: P2) => T, param1: P1, param2: P2): T;
    transform<T, P1, P2, P3>(func: (param1?: P1, param2?: P2, param3?: P3) => T, param1: P1, param2: P2, param3: P3): T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CFunctionCaller, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CFunctionCaller>;
}
/**
 * Calls a function in a template
 */
declare class FunctionCaller implements PipeTransform {
    f: CFunctionCaller;
    constructor(f: CFunctionCaller);
    transform: {
        <T>(func: () => T): T;
        <T, P1>(func: (param1?: P1) => T, param1: P1): T;
        <T, P1, P2>(func: (param1?: P1, param2?: P2) => T, param1: P1, param2: P2): T;
        <T, P1, P2, P3>(func: (param1?: P1, param2?: P2, param3?: P3) => T, param1: P1, param2: P2, param3: P3): T;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionCaller, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller, "functionCaller", true>;
}
/**
 * Variant of functionCaller for specific parameter counts
 */
declare class FunctionCaller1 implements PipeTransform {
    f: CFunctionCaller;
    constructor(f: CFunctionCaller);
    transform: {
        <T>(func: () => T): T;
        <T, P1>(func: (param1?: P1) => T, param1: P1): T;
        <T, P1, P2>(func: (param1?: P1, param2?: P2) => T, param1: P1, param2: P2): T;
        <T, P1, P2, P3>(func: (param1?: P1, param2?: P2, param3?: P3) => T, param1: P1, param2: P2, param3: P3): T;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionCaller1, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller1, "functionCaller1", true>;
}
/**
 * Variant of functionCaller for specific parameter counts
 */
declare class FunctionCaller2 implements PipeTransform {
    f: CFunctionCaller;
    constructor(f: CFunctionCaller);
    transform: {
        <T>(func: () => T): T;
        <T, P1>(func: (param1?: P1) => T, param1: P1): T;
        <T, P1, P2>(func: (param1?: P1, param2?: P2) => T, param1: P1, param2: P2): T;
        <T, P1, P2, P3>(func: (param1?: P1, param2?: P2, param3?: P3) => T, param1: P1, param2: P2, param3: P3): T;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionCaller2, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller2, "functionCaller2", true>;
}
/**
 * Variant of functionCaller for specific parameter counts
 */
declare class FunctionCaller3 implements PipeTransform {
    f: CFunctionCaller;
    constructor(f: CFunctionCaller);
    transform: {
        <T>(func: () => T): T;
        <T, P1>(func: (param1?: P1) => T, param1: P1): T;
        <T, P1, P2>(func: (param1?: P1, param2?: P2) => T, param1: P1, param2: P2): T;
        <T, P1, P2, P3>(func: (param1?: P1, param2?: P2, param3?: P3) => T, param1: P1, param2: P2, param3: P3): T;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionCaller3, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller3, "functionCaller3", true>;
}
/**
 * Calls an HTTP observable function with no parameters
 */
declare class HttpListCaller implements PipeTransform {
    /**
     * Executes an HTTP observable function with no parameters
     * @param httpObservable Function that returns an Observable
     * @returns The Observable returned by the function
     */
    transform<T>(httpObservable: () => Observable<T>): Observable<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpListCaller, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HttpListCaller, "httpListCaller", true>;
}
/**
 * Calls an HTTP observable function with one parameter
 */
declare class HttpListCaller1 implements PipeTransform {
    /**
     * Executes an HTTP observable function with one parameter
     * @param httpObservable Function that returns an Observable
     * @param param Parameter to pass to the function
     * @returns The Observable returned by the function
     */
    transform<T>(httpObservable: (param: any) => Observable<T>, param: any): Observable<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpListCaller1, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HttpListCaller1, "httpListCaller1", true>;
}
/**
 * Calls an HTTP observable function with two parameters
 */
declare class HttpListCaller2 implements PipeTransform {
    /**
     * Executes an HTTP observable function with two parameters
     * @param httpObservable Function that returns an Observable
     * @param param1 First parameter to pass to the function
     * @param param2 Second parameter to pass to the function
     * @returns The Observable returned by the function
     */
    transform<T>(httpObservable: (param1: string, param2: string) => Observable<T>, param1: string, param2: string): Observable<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpListCaller2, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HttpListCaller2, "httpListCaller2", true>;
}
/**
 * Determines if the current page is a show page
 */
declare class IsShowPage implements PipeTransform {
    /**
     * Checks if the page type is a show page
     * @param type The page type to check
     * @returns True if it's a show page, false otherwise
     */
    transform(type: EPageType): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsShowPage, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsShowPage, "isShowPage", true>;
}
/**
 * Determines if the current page is a clone page
 */
declare class IsClonePage implements PipeTransform {
    /**
     * Checks if the page type is a clone page
     * @param type The page type to check
     * @returns True if it's a clone page, null otherwise
     */
    transform(type: EPageType): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsClonePage, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsClonePage, "isClonePage", true>;
}
/**
 * Filters an array based on a query object or custom function
 */
declare class FilterArrayPipe implements PipeTransform {
    /**
     * Filters an array based on a query object or custom function
     * @param arr Array of items to filter
     * @param value Filter criteria as an object with field-value pairs
     * @param filterFunction Optional custom filter function
     * @returns Filtered array
     */
    transform<T extends {
        [x: string]: any;
    }>(arr: T[], value: {
        [x in keyof Partial<T>]: any;
    }, filterFunction?: (value: T, index?: number, array?: T[]) => boolean): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterArrayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterArrayPipe, "filterArray", true>;
}
/**
 * Filters an array of FormGroups based on their values
 */
declare class FilterFormArrayGroupPipe implements PipeTransform {
    /**
     * Filters an array of FormGroups based on their values
     * @param arr Array of FormGroups to filter
     * @param queryObject Filter criteria as an object with field-value pairs
     * @param filterFunction Optional custom filter function
     * @returns Filtered array of FormGroups
     */
    transform<TGroup extends FormGroup>(arr: TGroup[], queryObject: {
        [x: string]: string | boolean | number;
    }, filterFunction?: (value: TGroup, index?: number, array?: TGroup[]) => boolean): TGroup[];
    /**
     * Maps a query object to a format suitable for filtering
     * @param query The query object to map
     * @returns Array of key-value-type objects for filtering
     */
    queryMapper: (query: IObjectLiteral) => {
        key: string;
        value: string | boolean | number;
        type: TypeOf;
    }[];
    /**
     * Creates a filter function based on query parameters
     * @param queryObject Array of key-value-type objects to filter by
     * @param exactMatch Whether to require exact matches
     * @returns Filter function for FormGroups
     */
    filterFunc: (_queryObject: {
        key: string;
        value: string | boolean | number;
        type: TypeOf;
    }[], exactMatch?: boolean) => <TGroup extends FormGroup>(group: TGroup) => boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterFormArrayGroupPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterFormArrayGroupPipe, "filterFormArrayGroup", true>;
}
/**
 * Filters an array of form controls based on their values
 */
declare class FilterFormArrayControlPipe implements PipeTransform {
    uS: UtilityService;
    /**
     * Filters an array of form controls based on their values
     * @param arr Array of form controls to filter
     * @param value Value to filter by
     * @returns Filtered array of form controls
     */
    transform<TControl extends AbstractControl<any> = any>(arr: TControl[], value: string | boolean | number): TControl[];
    constructor(uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterFormArrayControlPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterFormArrayControlPipe, "filterFormArrayControl", true>;
}
/**
 * Sorts an array by a specified field and direction
 */
declare class SortPipe implements PipeTransform {
    /**
     * Sorts an array by a specified field and direction
     * @param arr Array to sort
     * @param direction 0 for ascending, 1 for descending
     * @param sortField Optional field to sort by
     * @returns Sorted array
     */
    transform<T>(arr: T[], direction?: 0 | 1, sortField?: keyof T): T[];
    sort<T>(arr: T[], direction: 0 | 1, sortField?: string): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SortPipe, "sort", true>;
}
/**
 * Helper pipe to force Angular change detection
 */
declare class RefresherPipe implements PipeTransform {
    /**
     * Returns a value when the refresher value changes, forcing change detection
     * @param value Value to be returned
     * @param refresher Refresher value for updating the value
     * @returns The original value
     */
    transform<T>(value: T, refresher?: any): T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RefresherPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<RefresherPipe, "refresher", true>;
}
/**
 * Casts a value to any type
 */
declare class ToAnyPipe implements PipeTransform {
    /**
     * Casts a value to any type
     * @param value The value to cast
     * @param isArray Whether to cast as an array
     * @returns The casted value
     */
    transform(value: any, isArray?: boolean): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToAnyPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToAnyPipe, "toAny", true>;
}
/**
 * Creates a stable context object for table cell templates.
 * Memoized by Angular's pure pipe mechanism.
 */
declare class TableContextPipe implements PipeTransform {
    transform(row: any, rowIndex: number): {
        $implicit: {
            row: any;
            rowIndex: number;
        };
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableContextPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TableContextPipe, "tableContext", true>;
}
/**
 * Casts a value to any array type
 */
declare class ToAnyArrayPipe implements PipeTransform {
    /**
     * Casts a value to any array type
     * @param value The value to cast
     * @returns The value as any[]
     */
    transform(value: any): any[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToAnyArrayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToAnyArrayPipe, "toAnyArray", true>;
}
/**
 * Trims a string
 */
declare class TrimPipe implements PipeTransform {
    /**
     * Trims a string
     * @param value String to trim
     * @returns Trimmed string
     */
    transform(value: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrimPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TrimPipe, "trim", true>;
}
declare class TrimTextPipe implements PipeTransform {
    /**
     * Trims a string based on a specified length
     * @param value String to trim
     * @param length Length to begin trimming
     * @returns Trimmed string
     */
    transform(value: string, length: number): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrimTextPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TrimTextPipe, "trimText", true>;
}
/**
 * Returns either the provided value or a default value
 */
declare class XOrYPipe implements PipeTransform {
    private uS;
    /**
     * Returns either the provided value or a default value
     * @param x The primary value to check
     * @param y The default value to use if x is empty
     * @returns x if it has a value, otherwise y
     */
    transform(x: string, y?: string): string;
    constructor(uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XOrYPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<XOrYPipe, "xOrY", true>;
}
/**
 * Replaces all occurrences of a string with another string
 */
declare class ReplaceAllPipe implements PipeTransform {
    /**
     * Replaces all occurrences of a string with another string
     * @param text The source text
     * @param search The string to search for
     * @param replacement The string to replace with
     * @returns Text with all occurrences replaced
     */
    transform(text: string, search: string, replacement: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReplaceAllPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ReplaceAllPipe, "replaceAll", true>;
}
/**
 * Returns the value or a default if the value is empty
 */
declare class ValueOrXPipe implements PipeTransform {
    /**
     * Returns the value or a default if the value is empty
     * @param value Variable that holds the value to be checked for emptiness
     * @param replacement This is the value that will be set if the subject field is empty
     * @returns Return the value or the replacement value if value is empty
     */
    transform<T>(value: T, replacement?: string): string | T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueOrXPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ValueOrXPipe, "valueOrX", true>;
}
/**
 * Concatenates two strings with a specified joiner
 */
declare class StrConcatenatorPipe implements PipeTransform {
    /**
     * Concatenates two strings with a specified joiner
     * @param text1 First string to concatenate
     * @param text2 Second string to concatenate
     * @param joiner String to join the two texts with
     * @returns Concatenated string
     */
    transform<T>(text1?: any | string | null, text2?: any | string | null, joiner?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrConcatenatorPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<StrConcatenatorPipe, "strConcatenator", true>;
}
/**
 * Converts a field name to a formatted label
 */
declare class FieldToLabelPipe implements PipeTransform {
    uS: UtilityService;
    /**
     * Converts a field name to a formatted label
     * @param fieldName The field name to format
     * @returns Formatted label
     */
    transform(fieldName: string): string;
    constructor(uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldToLabelPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FieldToLabelPipe, "fieldToLabel", true>;
}
/**
 * Casts a value to a specific type
 */
declare class TyperPipe implements PipeTransform {
    /**
     * Casts a value to a specific type
     * @param value The value to cast
     * @param sample Sample object of the target type
     * @returns The value cast to the target type
     */
    transform<T>(value: any, sample: T): T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TyperPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TyperPipe, "typer", true>;
}
/**
 * Filters an array using a pipe
 */
declare class FilterArrayByStringPipe implements PipeTransform {
    /**
     * Filter array using a pipe
     * @param arr Array to filter
     * @param value Value to filter for
     * @param keys Fields to check for match in
     * @param filterFunction Fitler function to use instead of value and keys
     * @returns
     */
    transform<T>(arr: T[], value: string, keys: (keyof T)[], filterFunction?: (value: T, index?: number, array?: T[]) => boolean): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterArrayByStringPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterArrayByStringPipe, "filterArrayByString", true>;
}
/**
 * Removes options that are already used in a form array
 */
declare class RemoveUsedOptionsPipe implements PipeTransform {
    /**
     * Filters an array to remove options already used in a form array
     * @param arr The array of options
     * @param formArray The form array to check against
     * @param form The current form
     * @param arrFieldName Optional field name in the option to compare
     * @param formFieldName Optional field name in the form to compare
     * @returns Filtered array with unused options
     */
    transform<TOption, TFormArray>(arr: TOption[], formArray: TFormArray[], form: TFormArray, arrFieldName?: keyof TOption, formFieldName?: keyof TFormArray): TOption[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RemoveUsedOptionsPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<RemoveUsedOptionsPipe, "removeUsedOptions", true>;
}
/**
 * Removes options that are already used in a reactive form array
 */
declare class RemoveUsedOptionsReactivePipe implements PipeTransform {
    /**
     * Filters an array to remove options already used in a reactive form array
     * @param arr The array of options
     * @param formArray The reactive form array to check against
     * @param form The current form
     * @param arrFieldName Optional field name in the option to compare
     * @param formFieldName Optional field name in the form to compare
     * @returns Filtered array with unused options
     */
    transform<TOption, TFormArray extends {
        value?: any;
    }[]>(arr: TOption[], formArray: TFormArray[], form: TFormArray, arrFieldName?: keyof TOption, formFieldName?: keyof TFormArray): TOption[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RemoveUsedOptionsReactivePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<RemoveUsedOptionsReactivePipe, "removeUsedOptionsReactive", true>;
}
/**
 * Converts an object to an array
 */
declare class ObjectToArrayPipe implements PipeTransform {
    /**
     * Converts an object to an array of its values
     * @param value The object to convert
     * @returns Array of the object's values
     */
    transform<T>(value: {
        [x: string]: T;
    }): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectToArrayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ObjectToArrayPipe, "objectToArray", true>;
}
/**
 * Provides responsive values based on screen size
 */
declare class ResponsiveValPipe implements PipeTransform {
    responsive: BreakpointObserver;
    /**
     * Returns a value based on the current screen size/breakpoint
     * @param config Object with values for different breakpoints
     * @returns The value corresponding to the current breakpoint
     */
    transform<T>(config: {
        XSmall?: T;
        Small?: T;
        Medium?: T;
        Large?: T;
        XLarge?: T;
        Handset?: T;
        Tablet?: T;
        Web?: T;
        HandsetPortrait?: T;
        TabletPortrait?: T;
        WebPortrait?: T;
        HandsetLandscape?: T;
        TabletLandscape?: T;
        WebLandscape?: T;
    }): T;
    ngOnDestroy(): void;
    constructor(responsive: BreakpointObserver);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponsiveValPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ResponsiveValPipe, "responsiveVal", true>;
}
declare class UtilityPipesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UtilityPipesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<UtilityPipesModule, never, [typeof i1$1.CommonModule, typeof ArraySplitter, typeof CustomDatePipe, typeof FieldToLabelPipe, typeof FilterArrayByStringPipe, typeof FilterArrayPipe, typeof FilterFormArrayGroupPipe, typeof FormInvalidClassPipe, typeof FunctionCaller, typeof FunctionCaller1, typeof FunctionCaller2, typeof FunctionCaller3, typeof GenderPipe, typeof GetValueLabel, typeof HasFormValuePipe, typeof HasValuePipe, typeof CodeTitleDescPipe, typeof HttpListCaller, typeof HttpListCaller1, typeof HttpListCaller2, typeof IsClonePage, typeof IsShowPage, typeof ObjectToArrayPipe, typeof RefresherPipe, typeof RemoveUsedOptionsPipe, typeof ReplaceAllPipe, typeof ResponsiveValPipe, typeof RoundPipe, typeof SecondsToTimePipe, typeof SortPipe, typeof StrConcatenatorPipe, typeof ToAnyArrayPipe, typeof ToAnyPipe, typeof SDKTranslatePipe, typeof TrimPipe, typeof TrimTextPipe, typeof ValueFormatterPipe, typeof ValueOrXPipe, typeof XOrYPipe, typeof TableContextPipe], [typeof ArraySplitter, typeof CustomDatePipe, typeof FieldToLabelPipe, typeof FilterArrayByStringPipe, typeof FilterArrayPipe, typeof FilterFormArrayGroupPipe, typeof FormInvalidClassPipe, typeof FunctionCaller, typeof FunctionCaller1, typeof FunctionCaller2, typeof FunctionCaller3, typeof GenderPipe, typeof GetValueLabel, typeof HasFormValuePipe, typeof HasValuePipe, typeof CodeTitleDescPipe, typeof HttpListCaller, typeof HttpListCaller1, typeof HttpListCaller2, typeof IsClonePage, typeof IsShowPage, typeof ObjectToArrayPipe, typeof RefresherPipe, typeof RemoveUsedOptionsPipe, typeof ReplaceAllPipe, typeof ResponsiveValPipe, typeof RoundPipe, typeof SecondsToTimePipe, typeof SortPipe, typeof StrConcatenatorPipe, typeof ToAnyArrayPipe, typeof ToAnyPipe, typeof SDKTranslatePipe, typeof TrimPipe, typeof TrimTextPipe, typeof ValueFormatterPipe, typeof ValueOrXPipe, typeof XOrYPipe, typeof TableContextPipe]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<UtilityPipesModule>;
}

/**
 * Component for managing and displaying field selections.
 * Allows users to drag and drop fields between active and inactive lists.
 */
declare class FieldsToDisplayComponent {
    /** Search query for filtering all fields */
    readonly query1: _angular_core.ModelSignal<string>;
    /** Search query for filtering non-active fields */
    readonly query2: _angular_core.ModelSignal<string>;
    /**
     * Sets the available fields for selection
     * @param v Array of table columns to be used as available fields
     */
    set _fields(v: TableCol[]);
    /**
     * Sets the currently active columns
     * @param v Array of table columns that are currently active
     */
    set _currentColumns(v: TableCol[]);
    /** Signal containing all available fields */
    readonly allFields: _angular_core.WritableSignal<TableCol<any>[]>;
    /** Computed signal for filtered fields based on query1 */
    readonly filteredAllFields: _angular_core.Signal<TableCol<any>[]>;
    /** Computed signal for active fields */
    readonly activeFields: _angular_core.Signal<TableCol<any>[]>;
    /** Computed signal for non-active fields, filtered by query2 and sorted by 't' */
    readonly nonActiveFields: _angular_core.Signal<TableCol<any>[]>;
    /** Event emitter for when fields selection changes */
    fieldsChanged: EventEmitter<{
        nFields: TableCol[];
        allFields: TableCol[];
    }>;
    /** Pipe for filtering arrays by string */
    filterArrayByStringPipe: FilterArrayByStringPipe;
    /** Utility service */
    uS: UtilityService<any>;
    constructor();
    /**
     * Handles drag and drop events between containers
     * @param event The drag drop event containing source and destination information
     */
    drop(event: CdkDragDrop<TableCol[]>): void;
    /**
     * Changes a non-active field to active
     * @param nonActiveObj The table column to set as active
     */
    changeToActive(nonActiveObj: TableCol): void;
    /**
     * Emits the fieldsChanged event with current field selections
     */
    emitFieldsChanged(): void;
    /**
     * Sets the type of a field to 'number' if the event is truthy
     * @param e The event that triggered this method
     * @param item The table column to potentially update
     */
    isNumType(e: any, item: TableCol): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldsToDisplayComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldsToDisplayComponent, "fields-to-display", never, { "query1": { "alias": "query1"; "required": false; "isSignal": true; }; "query2": { "alias": "query2"; "required": false; "isSignal": true; }; "_fields": { "alias": "fields"; "required": false; }; "_currentColumns": { "alias": "currentColumns"; "required": false; }; }, { "query1": "query1Change"; "query2": "query2Change"; "fieldsChanged": "fieldsChanged"; }, never, never, true, never>;
}

/**
 * Component for displaying form validation errors.
 *
 * This component aggregates and displays validation errors from one or more Angular forms.
 * It can handle FormGroups, FormControls, and FormArrays, and will recursively check for errors
 * in nested form structures.
 */
declare class FormErrorComponent {
    el: ElementRef<HTMLElement>;
    uS: UtilityService;
    readonly form: _angular_core.InputSignal<Form | Form[]>;
    protected readonly formErrorRes: _angular_core.ResourceRef<{
        formControl: AbstractControl;
        label: string;
        parent: string | null;
    }[]>;
    /** Signal containing all errors from the monitored form(s) */
    readonly errors: _angular_core.Signal<IError>;
    /** Input signal to enable custom result display */
    readonly customResult: _angular_core.InputSignal<boolean>;
    /** Input signal to display errors inline */
    readonly inline: _angular_core.InputSignal<boolean>;
    /** Input signal for large grid column count */
    readonly lgGridNo: _angular_core.InputSignal<number | "auto">;
    /** Input signal for extra-large grid column count */
    readonly xxlGridNo: _angular_core.InputSignal<number | "auto">;
    /** Computed signal indicating if any errors exist */
    readonly hasError: _angular_core.Signal<boolean>;
    /** Reference to the result template */
    readonly resultTemplateRef: _angular_core.Signal<TemplateRef<any>>;
    /** Reference to the error container element */
    readonly errContRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
    /**
     * Creates an instance of FormErrorComponent.
     * @param el Reference to the component's host element
     * @param uS Utility service for formatting and other operations
     * @param destroyerRef Reference for handling component destruction
     */
    constructor(el: ElementRef<HTMLElement>, uS: UtilityService);
    /**
     * Recursively collects error messages from a form or form control.
     * @param form The form or control to check for errors
     * @param formName Optional name of the form field
     * @param _index Optional index for array items
     * @param parent Optional parent form name for nested forms
     * @returns Array of error objects with form control references and labels
     */
    getErrorMessages(form: Form | AbstractControl, formName?: string, _index?: number, parent?: string): IError;
    /**
     * Toggles the visibility of the error container and scrolls it into view.
     * @param errCont Optional reference to the error container element
     */
    toggleErrors(errCont?: HTMLDivElement): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormErrorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormErrorComponent, "form-error", never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; "customResult": { "alias": "customResult"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "lgGridNo": { "alias": "lgGridNo"; "required": false; "isSignal": true; }; "xxlGridNo": { "alias": "xxlGridNo"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/** Type representing a form control, group, or array */
type Form = FormGroup | FormControl | FormArray;
/** Type representing an array of form error objects */
type IError = {
    formControl: AbstractControl;
    label: string;
    parent: string | null;
}[];

declare class ListOptionFinderPipe implements PipeTransform {
    iS: InputService;
    transform(value: string, options: {
        x: string;
    }[], valueField: string, labelField: string | string[], labelType: OptionLabelType, optionFormatter: (item: any) => string): string;
    constructor(iS: InputService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListOptionFinderPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ListOptionFinderPipe, "listOptionFinder", true>;
}
declare class FormGeneratedValueComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any> extends FormGeneratorComponent<TFormGroup> {
    listOptionFinderPipe: ListOptionFinderPipe;
    constructor();
    readonly computedListValue: _angular_core.Signal<{
        formattedValue: string | number | boolean;
        children?: IFormSchema<TFormGroup>[];
        labelType?: OptionLabelType;
        field: keyof TFormGroup;
        subType?: ets_fe_ng_sdk.InputSubType;
        presetValue?: boolean;
        templateRef?: _angular_core.TemplateRef<any>;
        btns?: ets_fe_ng_sdk.IBtn[];
        _id?: string;
        asyncValidators?: _angular_forms.AsyncValidatorFn[];
        autoPickValueField?: boolean;
        checked?: boolean;
        clearOnDisable?: boolean;
        cls?: string;
        countryCode3?: string;
        debug?: boolean;
        decimalPoints?: number;
        disabled?: boolean;
        disabledIf?: (row: any, cellField?: string) => boolean;
        dontFormatAsInput?: boolean;
        endLabel?: string;
        endLabelTooltip?: string;
        extra?: any;
        form?: _angular_forms.FormGroup<TFormGroup>;
        formatter?: (row: { [K in keyof TFormGroup]: any; }, fieldName: keyof TFormGroup) => string;
        getCountryCode3Key?: string;
        hidden?: boolean;
        hint?: string;
        icon?: ets_fe_ng_sdk.IconType;
        id?: string;
        ignore?: boolean;
        isRequired?: boolean;
        isSearchField?: boolean;
        label?: string;
        labelField?: string | string[];
        max?: number;
        maxLength?: number;
        min?: number;
        minLength?: number;
        noFormat?: boolean;
        onChangeFunc?: (row: { [K in keyof TFormGroup]?: TFormGroup[K]["value"]; }, cellValue?: any, component?: FormGeneratorComponent<TFormGroup, IFormSchema<TFormGroup>>) => any;
        onFormChange?: (row: { [K in keyof TFormGroup]?: TFormGroup[K]["value"]; }, cellValue?: any, component?: FormGeneratorComponent<TFormGroup, IFormSchema<TFormGroup>>) => any;
        onFormChangePipeOperators?: () => rxjs.OperatorFunction<any, any>;
        onRemoveFunc?: (row: { [K in keyof TFormGroup]?: TFormGroup[K]["value"]; }, cellValue?: any, component?: FormGeneratorComponent<TFormGroup, IFormSchema<TFormGroup>>) => any;
        optionFormatter?: (item: any) => string;
        options?: any[];
        optionsAsync?: rxjs.Observable<any[]> | Promise<any[]>;
        optionsFunc?: (...val: any) => rxjs.Observable<any[]>;
        optionsInitFunc?: rxjs.Observable<any[]>;
        optionsInitFunc2?: () => rxjs.Observable<any[]>;
        optionsKey?: string;
        placeholder?: string;
        searchFunc?: (...args: any) => any;
        selectedOptionLabel?: string;
        setAsCountryCode3?: boolean;
        setControlFormattedValue?: boolean;
        showRequiredTag?: boolean;
        showValidation?: boolean;
        showValidationIcon?: boolean;
        showValidationMsg?: boolean;
        skipDoesOptionExistCheck?: boolean;
        stacked?: boolean;
        tableFormatter?: (val: any) => string | undefined | Promise<string | undefined> | rxjs.Observable<string | undefined>;
        templateValue?: any;
        triggerOnChangeOnInit?: boolean;
        type?: ets_fe_ng_sdk.InputType;
        validators?: _angular_forms.ValidatorFn[];
        value?: any;
        valueField?: string;
        verbose?: boolean;
        accept?: string;
    }[]>;
    formatValue: (item: IFormSchema, value: string | boolean | number) => string | boolean | number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormGeneratedValueComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormGeneratedValueComponent<any>, "form-generated-value", never, {}, {}, never, never, true, never>;
}

/**
 * Component that renders a form link element.
 * This component allows creating a link with dynamic values and routing capabilities.
 */
declare class FormLinkComponent implements OnInit {
    /**
     * Query parameters to be passed to the router link.
     * These parameters will be appended to the URL.
     */
    cqueryParams: {
        [x: string]: string;
    };
    /**
     * The target route for the link.
     * This should be a valid route path in the application.
     */
    crouterLink: string;
    /**
     * The current value to be displayed or used for lookup.
     */
    value: string;
    /**
     * Array of options to select from when displaying the link.
     * Used in conjunction with labelField and valueField for data binding.
     */
    options: any[];
    /**
     * The field name in the options array to use for displaying labels.
     */
    labelField: string;
    /**
     * The field name in the options array to use for values.
     */
    valueField: string;
    /**
     * Creates an instance of FormLinkComponent.
     */
    constructor();
    /**
     * Lifecycle hook that is called after data-bound properties are initialized.
     */
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormLinkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormLinkComponent, "form-link", never, { "cqueryParams": { "alias": "cqueryParams"; "required": false; }; "crouterLink": { "alias": "crouterLink"; "required": false; }; "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; "labelField": { "alias": "labelField"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormTabHeadersComponent implements OnInit {
    selectedIndex: number;
    tabs: ITab[];
    selectedIndexChange: EventEmitter<number>;
    constructor();
    ngOnInit(): void;
    changeTab(index: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormTabHeadersComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormTabHeadersComponent, "app-form-tabs-header", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; }, never, never, true, never>;
}

/**
 * Component for displaying information dialogs with customizable content and actions.
 * Supports different status types (success, info, danger, warning) and configurable buttons.
 */
declare class InfoDialogComponent implements OnInit {
    data: {
        text: string;
        heading: string;
        status: number;
        btns: IInfoDialogBtn[];
    };
    dialogRef: MatDialogRef<InfoDialogComponent>;
    /**
     * @param data Configuration data for the dialog
     * @param data.text Main content text to display
     * @param data.heading Dialog title/heading
     * @param data.status Status code determining the dialog's visual style (0=danger, 1=success, 2=info, 3=warning)
     * @param data.btns Array of button configurations to display
     * @param dialogRef Reference to the dialog instance
     */
    constructor(data: {
        text: string;
        heading: string;
        status: number;
        btns: IInfoDialogBtn[];
    }, dialogRef: MatDialogRef<InfoDialogComponent>);
    /** Lifecycle hook that is called after data-bound properties are initialized */
    ngOnInit(): void;
    /**
     * Handles the affirmative action for the dialog
     * @param btn Optional button configuration that triggered this action
     */
    yes(btn?: IInfoDialogBtn): void;
    /**
     * Handles the negative action for the dialog
     * Closes the dialog with a false result
     */
    no(): void;
    /**
     * Handles custom button actions
     * @param event The pointer event that triggered the action
     * @param item The button configuration
     */
    handleAction: (event: PointerEvent, item: IInfoDialogBtn) => void;
    /**
     * Returns the CSS class name based on the status code
     * @param status Status code (0=danger, 1=success, 2=info, 3=warning)
     * @returns CSS class name corresponding to the status
     */
    cls: (status?: 0 | 1 | 2 | 3) => "" | "info" | "danger" | "success" | "warning";
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoDialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfoDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare const InfoDialogModule: readonly [typeof InfoDialogComponent];

/**
 * Component that displays an information icon with an optional tooltip.
 * Used to provide additional context or help information to users.
 */
declare class InfoIconComponent {
    /** The text to display in the tooltip when hovering over the info icon */
    readonly text: _angular_core.InputSignal<string>;
    /** Whether the icon should be displayed with color. Defaults to true */
    readonly coloured: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether the tooltip should be positioned to the left of the icon. Defaults to false */
    readonly left: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether the tooltip should be positioned to the right of the icon. Defaults to true */
    readonly right: _angular_core.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfoIconComponent, "app-info-icon", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "coloured": { "alias": "coloured"; "required": false; "isSignal": true; }; "left": { "alias": "left"; "required": false; "isSignal": true; }; "right": { "alias": "right"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * @deprecated The method should not be used. Use app-input-td-rf instead
 *
 * Component for handling input fields with NgModel binding.
 * This component supports various input types and configurations.
 */
declare class InputNGModelComponent implements OnInit {
    iS: InputService;
    /** Internal storage for the input value */
    __value: string | number;
    /** Raw options data before formatting */
    rawOptions: any[];
    /** Input type (text, number, checkbox, etc.) */
    type: string;
    /**
     * Sets the value of the input
     * @param v The value to set
     */
    set _value(v: string | number);
    /** CSS class to apply to the component */
    cls?: string;
    /** Whether the input should be colored */
    colored: boolean;
    /** Whether the input is disabled */
    disabled: boolean;
    /** Whether to hide the input */
    hide: boolean;
    /** Hint text to display with the input */
    readonly hint: _angular_core.InputSignal<string>;
    /** ID for the input element */
    id: string;
    /** CSS class for the input element */
    inpCl: string;
    /** Label text for the input */
    label: string;
    /** CSS class for the label */
    lblCl: string;
    /** Position of the label relative to the input */
    lblPosition: 'left' | 'right';
    /** Whether to use mini styling */
    mini: boolean;
    /** Whether to use light styling */
    light: boolean;
    /** Name attribute for the input */
    name: string;
    /** NgModel binding value */
    model: any;
    /** Event emitted when model changes */
    modelChange: EventEmitter<any>;
    /** Function to format option items for display */
    optionFormatter: (item: any) => string;
    /** Formatted options for select inputs */
    options: IOption[];
    /** Observable stream of options */
    options$: EventEmitter<IOption<any>[]>;
    /**
     * Sets the options for select inputs
     * @param v Array of option items
     */
    set _options(v: any[]);
    /** Whether checkbox is checked (for checkbox type) */
    checked?: boolean;
    /** Additional context data */
    contextData: any;
    /** Number of decimal points for number inputs */
    decimalPoints: number;
    /** Field to use as label in options */
    labelField: string;
    /** Maximum value for number inputs */
    max: number;
    /** Minimum value for number inputs */
    min: number;
    /** Placeholder text */
    placeholder: string;
    /** Prefix text to display before input */
    prefix: string;
    /** Whether the input is read-only */
    readonly: boolean;
    /** Whether the input is required */
    required?: boolean;
    /** Whether to show an empty option in select inputs */
    showEmptyOption?: boolean;
    /** Whether to show the label */
    showLabel: boolean;
    /** Whether to show validation messages */
    showValidation: boolean;
    /** Whether to show validation icon */
    showValidationIcon: boolean;
    /** Whether to use small styling */
    small: boolean;
    /** Whether to use stacked layout */
    stacked: boolean;
    /** Suffix text to display after input */
    suffix: string;
    /** Theme to apply to the input */
    theme: InputTheme;
    /**
     * Sets the input type
     * @param v Input type value
     */
    set _type(v: InputType);
    /** Field to use as value in options */
    valueField: string;
    /** Type of value label to use for options */
    labelType: ValueType;
    /** Whether to use extra small styling */
    xsmall: boolean;
    /** Whether to show password (for password type) */
    showPassword: boolean;
    /** Event emitted when input value changes */
    mchange: EventEmitter<any>;
    /** Current input value */
    value: any;
    /** Input type enum */
    InputType: any;
    /** Reference to the label element */
    labelRef: ElementRef<HTMLLabelElement>;
    /**
     * Creates an instance of InputNGModelComponent
     * @param iS Input service for handling options formatting
     */
    constructor(iS: InputService);
    /** Lifecycle hook that is called after component initialization */
    ngOnInit(): void;
    /**
     * Lifecycle hook that is called when input properties change
     * @param changes SimpleChanges object containing changed properties
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Handles input change events
     * @param e Change event or value
     */
    change(e: any): void;
    /**
     * Handles file upload events
     * @param e Upload event
     */
    upload(e: any): void;
    /**
     * Logs the current value to console
     */
    log(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputNGModelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputNGModelComponent, "app-input-ngmodel", never, { "_value": { "alias": "mvalue"; "required": false; }; "cls": { "alias": "cls"; "required": false; }; "colored": { "alias": "colored"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hide": { "alias": "hide"; "required": false; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; "inpCl": { "alias": "inpCl"; "required": false; }; "label": { "alias": "label"; "required": false; }; "lblCl": { "alias": "lblCl"; "required": false; }; "lblPosition": { "alias": "lblPosition"; "required": false; }; "mini": { "alias": "mini"; "required": false; }; "light": { "alias": "light"; "required": false; }; "name": { "alias": "name"; "required": false; }; "model": { "alias": "model"; "required": false; }; "optionFormatter": { "alias": "optionFormatter"; "required": false; }; "_options": { "alias": "options"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "contextData": { "alias": "contextData"; "required": false; }; "decimalPoints": { "alias": "decimalPoints"; "required": false; }; "labelField": { "alias": "labelField"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showEmptyOption": { "alias": "showEmptyOption"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "showValidationIcon": { "alias": "showValidationIcon"; "required": false; }; "small": { "alias": "small"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "_type": { "alias": "type"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "labelType": { "alias": "labelType"; "required": false; }; "xsmall": { "alias": "xsmall"; "required": false; }; }, { "modelChange": "modelChange"; "mchange": "mchange"; }, never, never, true, never>;
}
/**
 * Input theme type
 * 1: Default theme
 * 2: Alternative theme
 */
type InputTheme = 1 | 2;
/**
 * Value type for option formatting
 * - ct: Custom type
 * - cd: Custom data
 * - cdt: Custom data type
 * - cmd: Custom model data
 */
type ValueType = 'ct' | 'cd' | 'cdt' | 'cmd';

/**
 * Component for displaying validation error messages for form controls using NgModel.
 * This component shows appropriate error messages based on the validation type.
 */
declare class ValidationMessageNgmodelComponent implements OnInit {
    private titleCasePipe;
    /** Flag indicating whether the validation error should be displayed */
    isError: boolean;
    /** The type of validation error that occurred */
    validationKey: EValidationType;
    /** The selected validation object containing type and message */
    validation: {
        type: EValidationType;
        message: string;
    };
    /** Label for the form control (optional) */
    label: string;
    /** Custom error message to display (defaults to 'Value is invalid') */
    customMessage: string;
    /** Name of the form control for use in error messages */
    name: any;
    /** Array of validation configurations with types and messages */
    validations: any;
    /**
     * Creates an instance of ValidationMessageNgmodelComponent.
     * @param titleCasePipe - Service for transforming text to title case
     */
    constructor(titleCasePipe: TitleCasePipe);
    /**
     * Initializes the component by setting up validation messages and determining
     * which validation message to display.
     */
    ngOnInit(): void;
    /**
     * Initializes the array of validation messages with their corresponding types.
     * Uses the control name in the messages, transformed to title case.
     */
    initializeValidationMessages(): void;
    /**
     * Sets the current validation message based on the validationKey input.
     * Finds the matching validation type in the validations array.
     */
    setValidation(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationMessageNgmodelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValidationMessageNgmodelComponent, "app-validation-message-ngmodel", never, { "isError": { "alias": "isError"; "required": false; }; "validationKey": { "alias": "validationKey"; "required": false; }; "label": { "alias": "label"; "required": false; }; "customMessage": { "alias": "customMessage"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for inputting time values in days, hours, and minutes format.
 * Extends InputBasicComponent to provide form control functionality.
 */
declare class DayHourMinInputComponent extends InputBasicComponent {
    /** Determines whether to clear the input when disabled. Default is false. */
    clearOnDisable: _angular_core.InputSignal<boolean>;
    /** When true, converts the time value to minutes. Default is false. */
    toMins: boolean;
    /** Form group containing the days, hours, and minutes inputs. */
    readonly subForm: FormGroup<{
        days: FormControl<any>;
        hours: FormControl<any>;
        mins: FormControl<any>;
    }>;
    /** Subscription for value changes. */
    sub1: Subscription;
    /** Subscription for status changes. */
    sub2: Subscription;
    /** Subscription for subForm value changes. */
    sub3: Subscription;
    /** Flag to control whether subForm should be updated. */
    updateSubForm: boolean;
    /** Signal for the subForm's raw value. */
    readonly subFormValue: _angular_core.Signal<{
        days: any;
        hours: any;
        mins: any;
    }>;
    /**
     * Function to handle disabling the component.
     * @param control - The form control to disable
     * @param disable - Whether to disable the control
     */
    protected disableFunc: (control: AbstractControl<any, any, any>, disable: boolean) => void;
    /**
     * Sets the time value in minutes and converts it to days, hours, and minutes.
     * @param value - Time value in minutes
     */
    set mins(value: number);
    /** Utility service for time conversions. */
    uS: UtilityService<any>;
    constructor();
    /**
     * Initializes the component, sets up subscriptions, and handles form state.
     */
    ngOnInit(): void;
    /**
     * Validates the subform based on the parent control's validation state.
     * @param form - The form group to validate
     */
    validateFromParent(form: FormGroup): void;
    /**
     * Cleans up subscriptions when the component is destroyed.
     */
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DayHourMinInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DayHourMinInputComponent, "app-day-hour-min-input", never, { "clearOnDisable": { "alias": "clearOnDisable"; "required": false; "isSignal": true; }; "toMins": { "alias": "toMins"; "required": false; }; "mins": { "alias": "mins"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component that wraps an input control with additional functionality.
 * Extends the base InputBasicComponent to provide form control integration.
 */
declare class InputControlComponent extends InputBasicComponent {
    /**
     * Sets the form control for this input component.
     * Creates a FormGroup with the control using the component's name.
     *
     * @param value - The FormControl to be used by this component
     */
    set setControl(value: FormControl);
    /**
     * Initializes the component with default values.
     * Sets the default name to 'control'.
     */
    constructor();
    /**
     * Lifecycle hook that is called after data-bound properties are initialized.
     * Calls the parent class's ngOnInit method.
     */
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputControlComponent, "input-control", never, { "setControl": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for rendering input labels with various styling options
 */
declare class InputLabelComponent {
    /** Whether the label should be colored */
    readonly colored: _angular_core.InputSignal<boolean>;
    /** Form control or form group associated with this label */
    readonly form: _angular_core.InputSignal<any>;
    /** Hint text to display with the label */
    readonly hint: _angular_core.InputSignal<string | number>;
    /** Show the hint without the tooltip */
    readonly inlineHint: _angular_core.InputSignal<boolean>;
    /** Unique identifier for the label */
    readonly id: _angular_core.InputSignal<string>;
    /** Whether the associated checkbox is invalid */
    readonly invalidCheckbox: _angular_core.InputSignal<boolean>;
    /** Whether the field is required */
    readonly isRequired: _angular_core.InputSignal<boolean>;
    /** Text content of the label */
    readonly label: _angular_core.InputSignal<string>;
    /** URL for making the label a clickable link */
    readonly labelLink: _angular_core.InputSignal<string>;
    /** CSS class for the label column width */
    readonly lblCl: _angular_core.InputSignal<string>;
    /** Whether to use light styling */
    readonly light: _angular_core.InputSignal<boolean>;
    /** Whether to use mini styling */
    readonly mini: _angular_core.InputSignal<boolean>;
    /** Whether to display the label */
    readonly showLabel: _angular_core.InputSignal<boolean>;
    /** Whether to display the required indicator */
    readonly showRequiredTag: _angular_core.InputSignal<boolean>;
    /** Whether to use small styling */
    readonly small: _angular_core.InputSignal<boolean>;
    /** Whether to stack the label and input vertically */
    readonly stacked: _angular_core.InputSignal<boolean>;
    /** Theme to apply to the input */
    readonly theme: _angular_core.InputSignal<InputTheme$1>;
    /** Whether to use extra small styling */
    readonly xsmall: _angular_core.InputSignal<boolean>;
    /**
     * Logs the current form value to the console
     */
    log(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputLabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputLabelComponent, "app-input-label", never, { "colored": { "alias": "colored"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "inlineHint": { "alias": "inlineHint"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidCheckbox": { "alias": "invalidCheckbox"; "required": false; "isSignal": true; }; "isRequired": { "alias": "isRequired"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelLink": { "alias": "labelLink"; "required": false; "isSignal": true; }; "lblCl": { "alias": "lblCl"; "required": false; "isSignal": true; }; "light": { "alias": "light"; "required": false; "isSignal": true; }; "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "showRequiredTag": { "alias": "showRequiredTag"; "required": false; "isSignal": true; }; "small": { "alias": "small"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "xsmall": { "alias": "xsmall"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated Use InputBasicComponent instead.
 * A flexible input component that extends InputBase to provide various input types.
 * This component is being phased out in favor of InputBasicComponent.
 */
declare class InputComponent extends InputBase implements OnInit {
    /** The input configuration object */
    inp: FCInput;
    /**
     * Sets the input configuration and updates form and name
     * @param v The input configuration object
     */
    set _inp(v: FCInput);
    /** Specifies file types that can be selected with file input */
    accept: string;
    /** Whether to enable browser autocomplete */
    autocomplete: boolean;
    /** Label to display at the end of the input */
    endLabel: string;
    /** Tooltip for the end label */
    endLabelTooltip: string;
    /** Files selected in a file input */
    files: File[];
    /** Unique identifier for the input */
    id: string;
    /** CSS class for the input element */
    inpCl: string;
    /** URL for the label to link to */
    labelLink: string;
    /** Whether the input is in loading state */
    loading: boolean;
    /** Whether to allow multiple selections (for select/file inputs) */
    multiple: boolean;
    /** Function that returns an Observable of options for select inputs */
    optionsFunc: (...val: any) => Observable<any[]>;
    /** Whether to show an empty option in select inputs */
    showEmptyOption?: boolean;
    /** Whether to display the input label */
    showLabel: boolean;
    /** Whether to show validation state */
    showValidation: boolean;
    /** Whether to show validation messages */
    showValidationMsg: boolean;
    /** Whether to show validation icons */
    showValidationIcon: boolean;
    /** Whether to use small styling */
    small: boolean;
    /** Whether to stack label and input vertically */
    stacked: boolean;
    /** Toggle for password visibility */
    showPassword: boolean;
    /** Internal value storage */
    __value: any;
    /**
     * Sets the input value
     * @param v The value to set
     */
    set _value(v: any);
    /** @inheritdoc */
    ngOnInit(): void;
    /**
     * Handles input change events
     * @param e The change event
     */
    change(e: any): void;
    /**
     * Handles file upload events
     * @param e The upload event
     */
    upload(e: any): void;
    /**
     * Logs the form to console in non-production environments
     */
    log(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "app-input-old", never, { "_inp": { "alias": "input"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "endLabel": { "alias": "endLabel"; "required": false; }; "endLabelTooltip": { "alias": "endLabelTooltip"; "required": false; }; "files": { "alias": "files"; "required": false; }; "id": { "alias": "id"; "required": false; }; "inpCl": { "alias": "inpCl"; "required": false; }; "labelLink": { "alias": "labelLink"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "optionsFunc": { "alias": "optionsFunc"; "required": false; }; "showEmptyOption": { "alias": "showEmptyOption"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "showValidationMsg": { "alias": "showValidationMsg"; "required": false; }; "showValidationIcon": { "alias": "showValidationIcon"; "required": false; }; "small": { "alias": "small"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "_value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for handling year and month input fields with template-driven and reactive forms support.
 * Extends the base InputTD_RFComponent to provide specialized functionality for year/month selection.
 */
declare class YearMonthTdRfComponent extends InputTD_RFComponent {
    /**
     * Input property for the year model value
     */
    yrModel: any;
    /**
     * Override of parent's clearOnDisable property
     * Determines whether the input fields should be cleared when disabled
     */
    clearOnDisable: _angular_core.InputSignal<boolean>;
    /**
     * Output event emitter for year model changes
     */
    yrModelChange: EventEmitter<any>;
    /**
     * Input property for the month model value
     */
    mthModel: any;
    /**
     * Output event emitter for month model changes
     */
    mthModelChange: EventEmitter<any>;
    /**
     * Initializes the component
     * Calls the parent's initialization method and sets the model to an empty string
     * @override
     */
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YearMonthTdRfComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YearMonthTdRfComponent, "app-input-year-month-td-rf", never, { "yrModel": { "alias": "yrModel"; "required": false; }; "clearOnDisable": { "alias": "clearOnDisable"; "required": false; "isSignal": true; }; "mthModel": { "alias": "mthModel"; "required": false; }; }, { "yrModelChange": "yrModelChange"; "mthModelChange": "mthModelChange"; }, never, never, true, never>;
}

/**
 * Service responsible for managing validation messages throughout the application.
 * Provides methods to update, clear, reset, and transform validation messages.
 */
declare class ValidationMessageService {
    /** Signal containing the current validation messages configuration */
    validationMessages: _angular_core.WritableSignal<{
        custom: {
            message?: string;
        };
        invalid: {
            message?: string;
        };
        maxlength: {
            message?: string;
        };
        minlength: {
            message?: string;
        };
        pattern: {
            message?: string;
        };
        required: {
            message?: string;
        };
        unique: {
            message?: string;
        };
        notUnique: {
            message?: string;
        };
        notFound: {
            message?: string;
        };
        used: {
            message?: string;
        };
        email: {
            message?: string;
        };
        pending: {
            message?: string;
        };
    }>;
    /**
     * Updates the validation messages with new values
     * @param v - Partial object containing validation messages to update
     */
    updateValidationMessages(v: Partial<ReturnType<typeof this.validationMessages>>): void;
    /**
     * Clears all validation messages
     */
    clearValidationMessages(): void;
    /**
     * Resets validation messages to their default configuration
     */
    resetValidationMessages(): void;
    /**
     * Transforms a validation error object into a human-readable message
     *
     * @param errObj - The validation error object
     * @param label - Optional field label to include in the message
     * @param maxLength - Optional maximum length value to replace in the message template
     * @param minLength - Optional minimum length value to replace in the message template
     * @param controlMessage - Optional custom message to use for custom validation types
     * @returns Formatted validation message string
     */
    transform(errObj: IValidationMessage, label?: string, maxLength?: number, minLength?: number, controlMessage?: any): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationMessageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ValidationMessageService>;
}

/**
 * Component that displays validation messages for form controls.
 * It can be used directly with a control or with an InputBasicComponent.
 */
declare class ValidationMessageComponent {
    /** Maximum length constraint for the input field */
    readonly _maxLength: InputSignal<number>;
    /** Minimum length constraint for the input field */
    readonly _minLength: InputSignal<number>;
    /** Form control to validate */
    readonly control: InputSignal<AbstractControl<any, any, any>>;
    /** Custom error message to display when validation fails */
    readonly customMessage: InputSignal<string>;
    /** Enable debug mode for troubleshooting */
    readonly debug: InputSignal<boolean>;
    /** Whether to apply margin styling to the validation message */
    readonly applyMargin: InputSignal<boolean>;
    /** Whether to show validation errors regardless of the control's dirty state */
    readonly ignoreDirtiness: InputSignal<boolean>;
    /** InputBasicComponent that contains the control to validate */
    readonly input: InputSignal<{
        control: Signal<AbstractControl>;
        labelSignal: InputSignal<string>;
        minLength: InputSignal<number>;
        minSignal: InputSignal<number | string>;
        maxLength: InputSignal<number>;
        maxSignal: InputSignal<number | string>;
    }>;
    /** Label for the input field */
    readonly label: _angular_core.ModelSignal<string>;
    /** Whether to hide overflow text in the validation message */
    readonly hideOverflow: InputSignal<boolean>;
    /** Configuration for translation service */
    readonly translationConfig: ITranslatorConfig;
    /** Computed control that resolves to either the direct control or the one from the input component */
    protected readonly computedControl: Signal<AbstractControl<any, any, any>>;
    /** Signal that notifies when the form field changes */
    protected readonly formEventsRes: _angular_core.ResourceRef<_angular_forms.ControlEvent<any>>;
    protected readonly formFieldNotifier: Signal<_angular_forms.ControlEvent<any>>;
    /** Computed minimum length from various sources */
    readonly minLength: Signal<number>;
    /** Computed maximum length from various sources */
    readonly maxLength: Signal<number>;
    /** Validation message service for transforming error messages */
    readonly vmS: ValidationMessageService;
    /** Current validation errors from the control */
    readonly errors: Signal<IObjectLiteral<any>>;
    /** Whether the control is in a pending state */
    readonly pending: Signal<boolean>;
    /** Whether the control is dirty */
    readonly dirty: Signal<boolean>;
    /** Whether the control has been touched */
    readonly touched: Signal<boolean>;
    /** Processed validation errors ready for display */
    readonly computedErrors: Signal<string[]>;
    /** Computed label from various sources */
    readonly labelComputed: Signal<string>;
    /**
     * Logs validation errors to console when debug mode is enabled
     */
    logErrors(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationMessageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValidationMessageComponent, "app-validation-message", never, { "_maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "_minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; "customMessage": { "alias": "customMessage"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "applyMargin": { "alias": "applyMargin"; "required": false; "isSignal": true; }; "ignoreDirtiness": { "alias": "ignoreDirtiness"; "required": false; "isSignal": true; }; "input": { "alias": "input"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hideOverflow": { "alias": "hideOverflow"; "required": false; "isSignal": true; }; }, { "label": "labelChange"; }, never, never, true, never>;
}
/**
 * Pipe that transforms validation errors into user-friendly messages.
 * Uses the ValidationMessageService to perform the transformation.
 */
declare class ErrorMessagePipe implements PipeTransform {
    /** Validation message service for transforming error messages */
    vmS: ValidationMessageService;
    /** Transform method that delegates to the ValidationMessageService */
    transform: (errObj: ets_fe_ng_sdk.IValidationMessage, label?: string, maxLength?: number, minLength?: number, controlMessage?: any) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorMessagePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ErrorMessagePipe, "errorMessage", true>;
}

declare class FilterOptions implements PipeTransform {
    transform(arr: any[], query: string, field?: string): any[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterOptions, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterOptions, "filterOptions", true>;
}
declare class OptionerPipe implements PipeTransform {
    transform(options: any[], labelField: any, idField?: any, basic?: boolean): {
        value: any;
        label: string;
    }[];
    arrToStr(labelField: string, x: any): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionerPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<OptionerPipe, "optioner", true>;
}
declare class ValidationMsg implements PipeTransform {
    transform(message: string, prefix?: string, suffix?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationMsg, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ValidationMsg, "validationMsg", true>;
}
declare class Validator implements PipeTransform {
    transform(validation: any, control: AbstractControl, update?: any): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Validator, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<Validator, "validator", true>;
}
declare class OptionLabeller implements PipeTransform {
    iS: InputService;
    transform(option: any, formatter?: any, optionType?: OptionLabelType, labelField?: string): string;
    constructor(iS: InputService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionLabeller, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<OptionLabeller, "optionLabeller", true>;
}
declare class OptionsFormatter implements PipeTransform {
    iS: InputService;
    transform: <TRow = any>(options: TRow[], config: {
        valueField?: keyof TRow;
        formatter?: (item: any) => string;
        labelType?: OptionLabelType;
        labelField?: keyof TRow | (keyof TRow)[];
        optionHintField?: keyof TRow;
        autoPickValueField?: boolean;
    }) => ets_fe_ng_sdk.IOption<TRow>[];
    constructor(iS: InputService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionsFormatter, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<OptionsFormatter, "optionsFormatter", true>;
}
declare class InputClassPipe implements PipeTransform {
    iS: InputService;
    transform: (inpCl: string, dirty?: boolean, valid?: boolean, invalid?: boolean, showValidation?: boolean) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputClassPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<InputClassPipe, "inputClass", true>;
}
declare class InputPipesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputPipesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<InputPipesModule, never, [typeof FilterOptions, typeof Validator, typeof ValidationMsg, typeof OptionerPipe, typeof OptionLabeller, typeof OptionsFormatter, typeof InputClassPipe], [typeof FilterOptions, typeof Validator, typeof ValidationMsg, typeof OptionerPipe, typeof OptionLabeller, typeof OptionsFormatter, typeof InputClassPipe]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<InputPipesModule>;
}

/**
 * InputModule is a collection of components, modules, and services related to form inputs.
 *
 * This module exports various input components and related modules to provide a comprehensive
 * set of form input capabilities including basic inputs, specialized inputs (day/hour/min, year/month),
 * validation, and supporting UI elements.
 *
 * @remarks
 * This is exported as a const array rather than using NgModule decorator pattern.
 * Consumers should spread this array into their module imports, but not component import.
 */
declare const InputModule: readonly [typeof ets_fe_ng_sdk.AutocompleteComponent, typeof ets_fe_ng_sdk.AutocompleteTdRfComponent, typeof ets_fe_ng_sdk.BtnComponent, typeof ets_fe_ng_sdk.BtnLgComponent, typeof DayHourMinInputComponent, typeof FormsModule, typeof InputBasicComponent, typeof InputComponent, typeof InputControlComponent, typeof InputLabelComponent, typeof InputPipesModule, typeof InputTD_RFComponent, typeof MatTooltipModule, typeof ReactiveFormsModule, typeof ValidationMessageComponent, typeof YearMonthTdRfComponent];

declare const InputComponents: readonly [typeof InputBasicComponent, typeof AutocompleteComponent, typeof InputControlComponent, typeof InputComponent, typeof InputTD_RFComponent, typeof DayHourMinInputComponent, typeof ValidationMessageComponent, typeof YearMonthTdRfComponent, typeof InputLabelComponent];

declare class LabelComponent implements OnInit {
    btnS: BtnService;
    animate: boolean;
    coloured: boolean;
    hint: string;
    light: boolean;
    mclass: string;
    showHelpIcon: boolean;
    small: boolean;
    stacked: boolean;
    text: string;
    xsmall: boolean;
    customIcon: string;
    icon: any;
    iconPosition: string;
    set _icon(v: IconType);
    constructor(btnS: BtnService);
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabelComponent, "app-label", never, { "animate": { "alias": "animate"; "required": false; }; "coloured": { "alias": "coloured"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "light": { "alias": "light"; "required": false; }; "mclass": { "alias": "mclass"; "required": false; }; "showHelpIcon": { "alias": "showHelpIcon"; "required": false; }; "small": { "alias": "small"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "text": { "alias": "text"; "required": false; }; "xsmall": { "alias": "xsmall"; "required": false; }; "_icon": { "alias": "icon"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component that displays various loading animations with configurable properties.
 * Supports different loader types that can cycle automatically or be set statically.
 */
declare class LoaderComponent {
    cdr: ChangeDetectorRef;
    /** Page loader instance to manage loading state */
    readonly loader: PageLoader;
    /** CSS class to apply to the loader container */
    readonly class: _angular_core.InputSignal<classes>;
    /** Text to display during loading */
    readonly text: _angular_core.InputSignal<string>;
    /**
     * Sets the loading state of the component
     * @param v Boolean value indicating whether loading is active
     */
    set _loading(v: boolean);
    /** Signal tracking the current loading state */
    readonly loading: _angular_core.WritableSignal<boolean>;
    /** Default height value when no specific height is provided */
    protected readonly defaultHeight = "100%";
    /**
     * Computes the height of the loader based on provided dimensions and ratio
     * @returns Calculated height as a string with 'px' suffix or default height
     */
    readonly computedHeight: _angular_core.Signal<string>;
    /**
     * Computes the minimum height for the loader
     * @returns Minimum height as a string with appropriate units
     */
    readonly computedMinHeight: _angular_core.Signal<string>;
    /**
     * Determines the CSS class to apply based on height settings
     * @returns CSS class string
     */
    readonly computedClass: _angular_core.Signal<string>;
    /** Explicit height in pixels for the loader */
    readonly height: _angular_core.InputSignal<number>;
    /** Explicit width in pixels for the loader */
    readonly width: _angular_core.InputSignal<number>;
    /** Whether to use a static loader or cycle through animations */
    readonly useStaticLoader: _angular_core.InputSignal<boolean>;
    /** Height to width ratio for calculating dimensions */
    readonly ratioHW: _angular_core.InputSignal<number>;
    /** Current index in the loader type list */
    readonly currentLoaderIndex: _angular_core.WritableSignal<number>;
    /** List of loader types to cycle through */
    readonly loaderTypeList: _angular_core.WritableSignal<ELoaderType[]>;
    /** Current loader type based on the current index */
    readonly currentLoaderType: _angular_core.Signal<ELoaderType>;
    /** Available loader types */
    readonly loaderTypes: _angular_core.WritableSignal<typeof ELoaderType>;
    /** Reference used for cleanup on component destruction */
    protected destroyerRef: DestroyRef;
    /**
     * Initializes the loader component and sets up animation cycling
     * @param cdr ChangeDetectorRef for triggering change detection
     */
    constructor(cdr: ChangeDetectorRef);
    /** Lifecycle hook for component initialization */
    ngOnInit(): void;
    /**
     * Advances to the next loader animation in the cycle
     */
    next(): void;
    /**
     * Starts the loader and updates the loading state
     */
    startLoader(): void;
    /**
     * Stops the loader and updates the loading state
     */
    stopLoader(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderComponent, "loader", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "_loading": { "alias": "loading"; "required": false; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "useStaticLoader": { "alias": "useStaticLoader"; "required": false; "isSignal": true; }; "ratioHW": { "alias": "ratioHW"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
type classes = 'vh-10' | 'vh-20' | 'vh-30' | 'vh-40' | 'vh-50' | 'vh-60' | 'vh-70' | 'vh-80' | 'vh-90' | 'vh-95' | 'vh-100';
declare enum ELoaderType {
    blinkingBlocks = "blinkingBlocks",
    bouncingBall = "bouncingBall",
    fadingBars = "fadingBars",
    ringRipples = "ringRipples",
    fadingCircles = "fadingCircles"
}

declare class BlinkingBlocksComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlinkingBlocksComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlinkingBlocksComponent, "blinking-blocks", never, {}, {}, never, never, true, never>;
}

declare class BouncingBallComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BouncingBallComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BouncingBallComponent, "bouncing-ball", never, {}, {}, never, never, true, never>;
}

declare class FadingBarsComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FadingBarsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FadingBarsComponent, "fading-bars", never, {}, {}, never, never, true, never>;
}

declare class FadingCirclesComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FadingCirclesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FadingCirclesComponent, "fading-circles", never, {}, {}, never, never, true, never>;
}

declare class RingRipplesComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RingRipplesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RingRipplesComponent, "ring-ripples", never, {}, {}, never, never, true, never>;
}

declare class SpinnerComponent {
    text: string;
    diameter: number;
    loading: boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "spinner", never, { "text": { "alias": "text"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, true, never>;
}

type GridValue = 1 | 2 | 3 | 4 | 5 | 6 | 'auto';
declare enum EGridPort {
    xxl = "xxl",
    lg = "lg",
    md = "md",
    sm = "sm"
}
/**
 * Pipe that transforms grid values into responsive grid configurations.
 * Can return either a mapping of breakpoints to grid values or a formatted class string.
 */
declare class ResizeGridPipe implements PipeTransform {
    /**
     * Transforms a grid value into a mapping of breakpoints to grid values.
     * @param value - The grid value to transform
     * @returns An object mapping each breakpoint to the appropriate grid value
     */
    transform(value: GridValue): {
        [k in EGridPort]: GridValue;
    };
    /**
     * Transforms a grid value into a formatted class string with the given prefix.
     * @param value - The grid value to transform
     * @param prefix - The prefix to add to each class
     * @returns A space-separated string of classes
     */
    transform(value: GridValue, prefix: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizeGridPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ResizeGridPipe, "resizeGrid", true>;
}
/**
 * Component for displaying a grid layout with standard CRUD operation buttons.
 * Provides a consistent interface for index/list views with configurable grid and button options.
 */
declare class IndexCompLayoutComponent {
    /** Number of columns in the grid layout */
    readonly grid: InputSignal<1 | "auto" | 5 | 2 | 3 | 4 | 6>;
    /** Whether to show the action buttons */
    readonly showButtons: InputSignal<boolean>;
    /** Whether to hide the clone button */
    readonly hideClone: InputSignal<boolean>;
    /** Whether to hide the show/view button */
    readonly hideShow: InputSignal<boolean>;
    /** Whether to hide the edit button */
    readonly hideEdit: InputSignal<boolean>;
    /** Whether to validate before creating */
    readonly validateCreate: InputSignal<boolean>;
    /** Text to display on the create button */
    readonly createBtnText: InputSignal<string>;
    /** Whether to hide the create button */
    readonly hideCreate: InputSignal<boolean>;
    /** Whether the form is valid (enables/disables buttons) */
    readonly valid: InputSignal<boolean>;
    /** Whether the component is in a loading state */
    readonly loading: InputSignal<boolean>;
    /** Route parameters to pass when navigating */
    readonly routeValue: InputSignal<{
        [x: string]: string | number | null | undefined;
    }>;
    /** Router service for navigation */
    router: Router;
    /** Current activated route */
    route: ActivatedRoute;
    /** Computed signal that returns the number of visible buttons */
    readonly buttonGridSignal: _angular_core.Signal<number>;
    /**
     * Navigates to the create route if the form is valid.
     * Uses the current route as the base and adds query parameters from routeValue.
     */
    create(): void;
    /**
     * Navigates to the edit route if the form is valid.
     * Uses the current route as the base and adds query parameters from routeValue.
     */
    edit(): void;
    /**
     * Navigates to the show/view route if the form is valid.
     * Uses the current route as the base and adds query parameters from routeValue.
     */
    show(): void;
    /**
     * Navigates to the clone route if the form is valid.
     * Uses the current route as the base and adds query parameters from routeValue.
     */
    clone(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexCompLayoutComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexCompLayoutComponent, "index-comp-layout", never, { "grid": { "alias": "grid"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "hideClone": { "alias": "hideClone"; "required": false; "isSignal": true; }; "hideShow": { "alias": "hideShow"; "required": false; "isSignal": true; }; "hideEdit": { "alias": "hideEdit"; "required": false; "isSignal": true; }; "validateCreate": { "alias": "validateCreate"; "required": false; "isSignal": true; }; "createBtnText": { "alias": "createBtnText"; "required": false; "isSignal": true; }; "hideCreate": { "alias": "hideCreate"; "required": false; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "routeValue": { "alias": "routeValue"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * Component that combines a modal dialog with a form generator.
 * Extends the base ModalComponent to provide form functionality within a modal dialog.
 */
declare class ModalFormComponent extends ModalComponent {
    /**
     * Determines which field to use as the key in the form schema.
     * Can be either 'field' or 'label'.
     * @default 'field'
     */
    keyField: 'field' | 'label';
    /**
     * Event emitted when the form is submitted.
     * Emits the form value.
     */
    submitted: EventEmitter<any>;
    /**
     * Function to be called when the form is submitted.
     * Should return a Promise that resolves with the result of the submission.
     */
    submitFunc: (value: any) => Promise<any>;
    /**
     * Text to display on the submit button.
     * @default 'Save'
     */
    text: string;
    /**
     * Additional data to provide context for the form.
     */
    contextData: any;
    /**
     * Grid column count for default screen sizes.
     */
    gridStyle: number;
    /**
     * Grid column count for medium screen sizes.
     */
    gridMDStyle: number;
    /**
     * Grid column count for extra-extra-large screen sizes.
     */
    gridXXLStyle: number;
    /**
     * The Angular FormGroup instance for the form.
     */
    form: FormGroup;
    /**
     * Form instance for standalone components.
     */
    standaloneForm: any;
    /**
     * Schema defining the structure and behavior of the form.
     */
    formSchema: IFormSchema[];
    /**
     * Map of options for select/dropdown fields in the form.
     */
    optionsMap: IFormOptions;
    /**
     * Country codes for cell/mobile phone fields.
     */
    cellCountryCode3s: IFormOptions;
    /**
     * Opens the modal with the provided configuration.
     * Extends the base modal open method to handle context data.
     * @param config - Configuration for opening the modal, including context data
     */
    open(config: IModalOpenConfig & {
        contextData: any;
    }): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalFormComponent, "modal-form", never, { "keyField": { "alias": "keyField"; "required": false; }; "submitFunc": { "alias": "submitFunc"; "required": false; }; "text": { "alias": "text"; "required": false; }; "contextData": { "alias": "contextData"; "required": false; }; "gridStyle": { "alias": "gridStyle"; "required": false; }; "gridMDStyle": { "alias": "gridMDStyle"; "required": false; }; "gridXXLStyle": { "alias": "gridXXLStyle"; "required": false; }; "form": { "alias": "form"; "required": false; }; "formSchema": { "alias": "formSchema"; "required": false; }; }, { "submitted": "submitted"; }, never, never, true, never>;
}

/**
 * Modal header component that provides a standardized header for modal dialogs.
 * Includes a title and close button functionality.
 */
declare class ModalHeaderComponent {
    /**
     * Reference to the dialog that contains this header.
     * Used to close the dialog when the close button is clicked.
     */
    readonly dialogRef: _angular_core.InputSignal<MatDialogRef<any, any>>;
    /**
     * The text to display as the header/title of the modal.
     */
    readonly header: _angular_core.InputSignal<string>;
    /**
     * Value to pass to the dialog's close function when closing the modal.
     * This value will be available to the component that opened the dialog.
     */
    readonly onCloseValue: _angular_core.InputSignal<any>;
    /**
     * Event emitted when the close button is clicked.
     * Can be used by parent components to perform additional actions on close.
     */
    readonly onClose: _angular_core.OutputEmitterRef<void>;
    constructor();
    /**
     * Closes the dialog and emits the close event.
     * If dialogRef is provided, it will close the dialog with the onCloseValue.
     */
    protected close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalHeaderComponent, "modal-header", never, { "dialogRef": { "alias": "dialogRef"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "onCloseValue": { "alias": "onCloseValue"; "required": false; "isSignal": true; }; }, { "onClose": "close"; }, never, ["[headerBtns]"], true, never>;
}

declare const ModalComponents: readonly [typeof ModalComponent, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof ModalBodyDirective, typeof ModalFooterDirective];

interface IWebcamMedia {
    /**The latest file created between the last interval */
    latestFile: File;
    /**The latest blob created between the last interval */
    latestBlob: Blob;
    dataURI?: string;
}

/**
 * Component for capturing webcam media (images or videos)
 *
 * This component provides functionality to:
 * - Capture images from webcam
 * - Record video with optional audio
 * - Preview captured media
 * - Save or cancel the captured media
 */
declare class WebcamMediaComponent {
    cdr: ChangeDetectorRef;
    /** Emits when the component is closed, providing the captured media or null if canceled */
    closed: EventEmitter<IWebcamMedia>;
    /** Emits when the recorder is stopped */
    recorderStopped: EventEmitter<Event>;
    /** Emits when the recorder encounters an error */
    recorderErrored: EventEmitter<Event>;
    /** Emits when the recorder starts */
    recorderStarted: EventEmitter<Event>;
    /** Emits the current recording state */
    recordingState: EventEmitter<RecordingState>;
    /** Emits when the recording changes */
    recordingChanged: EventEmitter<IWebcamMedia>;
    /** Emits when a new image snapshot is taken */
    newImageSnapshot: EventEmitter<IWebcamMedia>;
    /** Emits when a webcam error occurs */
    webcamError: EventEmitter<any>;
    /** Optional template for custom controls */
    readonly controlTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Whether to capture video (true) or image (false) */
    readonly isVideo: _angular_core.InputSignal<boolean>;
    /** Whether to include audio in video recordings */
    readonly useAudio: _angular_core.InputSignal<boolean>;
    /** Custom filename for the captured media */
    readonly fileName: _angular_core.InputSignal<string>;
    /** Factory function to generate filename based on component state */
    readonly fileNameFactory: _angular_core.InputSignal<(comp: WebcamMediaComponent) => string>;
    /** MIME type for the captured media */
    readonly fileType: _angular_core.InputSignal<string>;
    /** Additional CSS class to apply to the component */
    readonly extraClass: _angular_core.InputSignal<string>;
    /**
     * Interval in seconds for recording notifications
     */
    readonly recordingNotificationInterval: _angular_core.InputSignal<number>;
    /**
     * Interval in seconds for automatic image snapshots
     * Set to 0 to disable automatic snapshots
     */
    readonly imageSnapshotInterval: _angular_core.InputSignal<number>;
    /** Whether the webcam should run in the background */
    readonly isBackground: _angular_core.InputSignal<boolean>;
    readonly computedRecordingNotificationInterval: _angular_core.Signal<number>;
    readonly isPicture: _angular_core.Signal<boolean>;
    readonly subject: _angular_core.Signal<"Image" | "Video">;
    readonly isPaused: _angular_core.Signal<boolean>;
    computedFileType: _angular_core.Signal<string>;
    computedFileExtension: _angular_core.Signal<string>;
    computedFileName: _angular_core.Signal<string>;
    readonly streamingVideoTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly recordingVideoRef: _angular_core.Signal<ElementRef<HTMLVideoElement>>;
    readonly recordingVideoRefEl: _angular_core.Signal<HTMLVideoElement>;
    protected readonly streaming: _angular_core.WritableSignal<boolean>;
    protected readonly preview: _angular_core.WritableSignal<boolean>;
    readonly computedPreview: _angular_core.Signal<boolean>;
    readonly width: _angular_core.ModelSignal<number>;
    readonly height: _angular_core.Signal<number>;
    protected canvas: HTMLCanvasElement | undefined;
    /**Holds the image or video file and blob */
    protected readonly mediaFile: _angular_core.WritableSignal<IWebcamMedia>;
    readonly mediaFileLink: _angular_core.Signal<string>;
    protected readonly stream: _angular_core.WritableSignal<MediaStream>;
    protected sub: Subscription;
    protected recorder: MediaRecorder;
    readonly isRecording: _angular_core.Signal<boolean>;
    /**In Milliseconds */
    protected readonly recordedTimeMS: _angular_core.WritableSignal<number>;
    readonly recordedTime: _angular_core.Signal<number>;
    protected readonly loading: _angular_core.WritableSignal<boolean>;
    protected snapshotHandlerSub: Subscription;
    protected readonly snapshotHandler: _angular_core.EffectRef;
    /**
     * Initializes the component
     * @param cdr ChangeDetectorRef for triggering change detection
     */
    constructor(cdr: ChangeDetectorRef);
    /**
     * Initializes the webcam after the view is initialized
     */
    protected ngAfterViewInit(): void;
    /**
     * Cleans up resources when the component is destroyed
     */
    protected ngOnDestroy(): void;
    /**
     * Starts the webcam stream and initializes the canvas
     */
    protected startUpWebcam(): void;
    /**
     * Saves the captured media and closes the webcam
     * Emits the media through the closed EventEmitter
     */
    save(): void;
    /**
     * Cancels the capture process and closes the webcam
     * Emits null through the closed EventEmitter
     */
    cancel(): void;
    /**
     * Clears any captured media and returns to the streaming state
     */
    clear(): void;
    /**
     * Restarts the webcam capture process
     */
    retake(): void;
    /**
     * Shuts down the webcam stream and releases resources
     */
    closeWebcam(): void;
    /**
     * Captures a still image from the webcam stream
     * Only works when in picture mode (isPicture is true)
     */
    takePicture(): void;
    /**
     * Draws the current video frame to the canvas
     */
    protected paintCanvas(): void;
    /**
     * Starts recording video from the webcam stream
     * @param stream Optional MediaStream to record from, defaults to the current stream
     * @throws Error if stream is not available
     */
    startRecording: (stream?: MediaStream) => void;
    /**
     * Stops the current recording and switches to preview mode
     */
    stopRecording(): void;
    /**
     * Toggles between paused and recording states
     */
    pauseRecording(): void;
    /**
     * Stops recording and extracts the recorded video
     */
    extractRecordedVideo(): void;
    /**
     * Observable that extracts the current canvas content as an image file
     */
    protected extractImage: Observable<IWebcamMedia>;
    /**
     * Observable that extracts the current canvas content and sets it as the media file
     */
    protected extractAndSetImage: Observable<IWebcamMedia>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WebcamMediaComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WebcamMediaComponent, "lib-webcam-media", never, { "controlTemplate": { "alias": "controlTemplate"; "required": false; "isSignal": true; }; "isVideo": { "alias": "isVideo"; "required": false; "isSignal": true; }; "useAudio": { "alias": "useAudio"; "required": false; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; "fileNameFactory": { "alias": "fileNameFactory"; "required": false; "isSignal": true; }; "fileType": { "alias": "fileType"; "required": false; "isSignal": true; }; "extraClass": { "alias": "extraClass"; "required": false; "isSignal": true; }; "recordingNotificationInterval": { "alias": "recordingNotificationInterval"; "required": false; "isSignal": true; }; "imageSnapshotInterval": { "alias": "imageSnapshotInterval"; "required": false; "isSignal": true; }; "isBackground": { "alias": "isBackground"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "recorderStopped": "recorderStopped"; "recorderErrored": "recorderErrored"; "recorderStarted": "recorderStarted"; "recordingState": "recordingState"; "recordingChanged": "recordingChanged"; "newImageSnapshot": "newImageSnapshot"; "webcamError": "webcamError"; "width": "widthChange"; }, never, never, true, never>;
}

declare class NarrationHistoryCompComponent {
    isShow: boolean;
    loading: boolean;
    saveFunction: (data: Partial<IComment>) => Promise<any>;
    updateFunction: (data: IComment) => Promise<any>;
    deleteFunction: (id: number) => Observable<any>;
    listFunction: (query: IGetQuery) => Observable<ISearchResponse2<IComment>>;
    comments: IComment[];
    newComment: Partial<IComment>;
    currentUserName: string;
    ngOnInit(): void;
    trackByID: (index: any, item: any) => any;
    fetchComments(): void;
    /**
     * add workflow history
     * @param content
     */
    createComment(content: string, cb: any, btn?: BtnComponent): Promise<void>;
    deleteComment(id: number, btn?: BtnComponent): Promise<void>;
    updateComment(history: IComment, content?: string, cb?: any, btn?: BtnComponent): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NarrationHistoryCompComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NarrationHistoryCompComponent, "narration-history-comp", never, { "isShow": { "alias": "isShow"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "saveFunction": { "alias": "saveFunction"; "required": true; }; "updateFunction": { "alias": "updateFunction"; "required": true; }; "deleteFunction": { "alias": "deleteFunction"; "required": true; }; "listFunction": { "alias": "listFunction"; "required": true; }; }, {}, never, never, true, never>;
}
interface IComment {
    narration: string;
    createdBy?: string;
    createdOn?: string;
    id: number;
}

declare class PageCenterBodyComponent {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageCenterBodyComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageCenterBodyComponent, "page-center-body", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Base component for page templates that provides common functionality for CRUD operations.
 *
 * @template ModelData - The type of data model used by the page
 * @template TEnvironment - The environment configuration type, defaults to Environment
 */
declare class PageTemplateComponent<ModelData = any, TEnvironment extends SDKEnvironment = Environment> {
    /** Indicates whether the page is currently loading */
    loading: boolean;
    /** Signal that tracks the loading state */
    readonly loadingSignal: _angular_core.WritableSignal<boolean>;
    /** Signal that indicates if the component is being used in a modal */
    readonly isModal: _angular_core.WritableSignal<boolean>;
    /**
     * Sets the isModal signal value
     * @param v - Boolean value indicating if component is in modal mode
     */
    set _isModal(v: boolean);
    /** The data model for the page */
    modelData: ModelData;
    /** Callback function to execute when modal operation completes */
    modalOnComplete: (...args: any[]) => any;
    /** Event emitted when modal form is submitted */
    modalSubmitted: EventEmitter<any>;
    /** Identifier code for the current entity */
    code?: string;
    /** Signal to override the page type */
    readonly overridePageTypeSignal: _angular_core.WritableSignal<EPageType>;
    /**
     * Gets the current page type
     * @returns The current page type
     */
    get pageType(): EPageType;
    /**
     * Sets the page type
     * @param value - The page type to set
     */
    set pageType(value: EPageType);
    /** Field name used as the primary identifier (defaults to 'code') */
    idField: string;
    /** Signal computed to determine if the current page is in create mode */
    readonly isCreate: _angular_core.Signal<boolean>;
    /** Signal computed to determine if the current page is in index mode */
    readonly isIndex: _angular_core.Signal<boolean>;
    /** Signal computed to determine if the current page is in clone mode */
    readonly isClone: _angular_core.Signal<boolean>;
    /** Signal computed to determine if the current page is in edit mode */
    readonly isEdit: _angular_core.Signal<boolean>;
    /** Signal computed to determine if the current page is in show mode */
    readonly isShow: _angular_core.Signal<boolean>;
    /** Signal computed to determine if the current page is in show or edit mode */
    readonly isShowOrEdit: _angular_core.Signal<boolean>;
    /** Signal computed to determine if the current page is in show or edit or clone mode */
    readonly isShowOrEditOrClone: _angular_core.Signal<boolean>;
    /**
     * Gets the info function from the utility service
     * @returns The info function
     */
    get infoFunc(): (text: string, status?: 0 | 2 | 1, heading?: string, btns?: ets_fe_ng_sdk.IInfoDialogBtn[], disableClose?: boolean) => Promise<boolean>;
    /** The current activated route */
    route: ActivatedRoute;
    /** Utility service instance */
    uS: UtilityService<any>;
    /** Router instance */
    readonly router: Router;
    /**
     * Provides router utilities for relative navigation and parameter access within the component.
     * @see UtilityService.relativeRouter
     * @example
     * // Usage in template or component:
     * this.relativeRouter.navigate('details', { queryParams: { id: 1 } });
     */
    readonly relativeRouter: {
        route: ActivatedRoute;
        router: Router;
        navigate: (link: string, config?: i1.NavigationExtras | undefined) => Promise<boolean>;
        queryParams: i1.Params;
        pathParams: i1.Params;
    };
    constructor();
    /**
     * Initializes the page component
     * @param func - Optional function to execute during initialization
     * @param err - Optional error handler function
     */
    init(func?: () => Promise<any>, err?: () => any): Promise<void>;
    /**
     * Sets the loading state
     * @param v - Boolean value indicating loading state
     */
    setLoader: (v: boolean) => void;
    /** Signal computed to determine the current page state */
    readonly pageState: _angular_core.Signal<IPageState>;
    /** Sets the page type to index */
    setAsIndex(): void;
    /** Sets the page type to clone */
    setAsClone(): void;
    /** Sets the page type to create */
    setAsCreate(): void;
    /** Sets the page type to edit */
    setAsEdit(): void;
    /** Sets the page type to show */
    setAsShow(): void;
    /** Signal for the current query parameters */
    readonly queryParamsSignal: _angular_core.Signal<{
        code?: string;
        id?: string;
    }>;
    /**
     * Gets the current query parameters
     * @returns The current query parameters object
     */
    get _queryParams(): {
        code?: string;
        id?: string;
    };
    /**
     * Checks if required parameters are present
     * @param params - Array of parameter names to check (defaults to ['code'])
     */
    checkParams(params?: string[]): Promise<void>;
    /** Signal computed to determine if code should be hidden */
    readonly hideCode: _angular_core.Signal<boolean>;
    /**
     * Redirects to home page with an error message
     * @param error - The error to display
     */
    bounce(error: any): Promise<void>;
    /**
     * Handles form submission based on the current page type
     */
    handleForm(): void;
    /** Handler for edit mode form submission */
    ifEdit: () => void;
    /** Handler for create mode form submission */
    ifCreate: () => void;
    /** Handler for show mode form submission */
    ifShow: () => void;
    /** Handler for clone mode form submission */
    ifClone: () => void;
    /**
     * Executes a function if not in create mode
     * @param func - The function to execute
     */
    ifParams: (func: () => any) => void;
    /**
     * Handles actions after form submission is complete
     * @param config - Configuration object for post-submission actions
     * @param config.notificationMessage - Optional message to display
     * @param config.param - Optional query parameters to pass to the next route
     * @param config.route - Optional route to navigate to (defaults to '../show')
     */
    onSubmitComplete(config: {
        notificationMessage?: string;
        param?: IObjectLiteral;
        route?: string;
    }): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageTemplateComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageTemplateComponent<any, any>, "ng-component", never, { "_isModal": { "alias": "isModal"; "required": false; }; "modelData": { "alias": "modelData"; "required": false; }; }, { "modalSubmitted": "modalSubmitted"; }, never, never, true, never>;
}
/**
 * Interface representing the state of a page
 */
interface IPageState {
    /** Indicates if the page is in clone mode */
    isClone?: boolean;
    /** Indicates if the page is in create mode */
    isCreate?: boolean;
    /** Indicates if the page is in edit mode */
    isEdit?: boolean;
    /** Indicates if the page is in show mode */
    isShow?: boolean;
    /** Indicates if the page is in modal mode */
    isModal?: boolean;
}

declare class PageToComponentDirective {
    viewContainerRef: ViewContainerRef;
    constructor(viewContainerRef: ViewContainerRef);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageToComponentDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PageToComponentDirective, "[appPageToComponent]", never, {}, {}, never, never, true, never>;
}

/**
 * Component that dynamically loads another component into a dialog.
 * Used for displaying page components in a modal dialog context.
 */
declare class PageToComponentComponent implements OnInit {
    data: {
        component: Type<PageTemplateComponent>;
        modelData: any;
        title: string;
        pageType: EPageType;
    };
    dialogRef: MatDialogRef<PageToComponentComponent>;
    /** Reference to the directive where the dynamic component will be loaded */
    compHost: PageToComponentDirective;
    /**
     * @param data Configuration data for the component
     * @param data.component The component type to be dynamically loaded
     * @param data.modelData Data to be passed to the loaded component
     * @param data.title Title of the dialog
     * @param data.pageType Type of page being displayed
     * @param dialogRef Reference to the dialog containing this component
     */
    constructor(data: {
        component: Type<PageTemplateComponent>;
        modelData: any;
        title: string;
        pageType: EPageType;
    }, dialogRef: MatDialogRef<PageToComponentComponent>);
    /**
     * Initializes the component by loading the dynamic component
     */
    ngOnInit(): void;
    /**
     * Loads the dynamic component into the view container
     * and sets up its properties and callback
     */
    loadComponent(): void;
    /**
     * Handles completion of the modal operation
     * @param data Data to be returned when the dialog closes
     */
    onComplete(data: any): void;
    /**
     * Closes the dialog without returning data
     */
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageToComponentComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageToComponentComponent, "ng-component", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Base component for pages that can be displayed in a modal dialog
 * @template ModelData Type of the data model used by the component
 * @template CompletionFunc Type of the completion function
 */
declare class PageModal<ModelData = any, CompletionFunc = any> {
    /** Indicates whether the component is being displayed in a modal */
    isModal: boolean;
    /** Data model for the component */
    modelData: ModelData;
    /** Function to be called when the modal operation completes */
    modalOnComplete: CompletionFunc;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageModal<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageModal<any, any>, "ng-component", never, { "isModal": { "alias": "isModal"; "required": false; }; "modelData": { "alias": "modelData"; "required": false; }; "modalOnComplete": { "alias": "modalOnComplete"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * Service responsible for opening Angular components as modal dialogs.
 *
 * This service provides functionality to display components within a modal dialog
 * using Angular Material's MatDialog. It wraps components in a PageToComponentComponent
 * which provides a consistent modal interface.
 */
declare class PageToComponentService {
    dialog: MatDialog;
    /**
     * Creates an instance of PageToComponentService.
     *
     * @param dialog - Angular Material's MatDialog service for opening modal dialogs
     */
    constructor(dialog: MatDialog);
    /**
     * Opens a component as a modal
     * @param component Component to be opened
     * @param title Value to be set as the header of the modal
     * @param modelData Data to pass into the component as variable `modelData`
     * @param pageType Page type to be set on the component
     * @param modalConfig Modal configuration object to be passed to `MatDialog`
     * @returns The `MatDialog.afterClosed` Observable
     */
    pageToModalOpener<ModalData, TComponent extends PageTemplateComponent<ModalData>>(component: Type<TComponent>, title: string, modelData?: ModalData, pageType?: EPageType, modalConfig?: MatDialogConfig): rxjs.Observable<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageToComponentService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageToComponentService>;
}

/**
 * A component that wraps Angular Material's MatPaginator to provide pagination functionality.
 * This component supports signals-based inputs and outputs for modern Angular applications.
 */
declare class PaginatorComponent {
    /** The length of the total number of items that are being paginated. */
    readonly arrayLength: _angular_core.InputSignal<number>;
    /** The number of items to display on a page. Default is 10. */
    readonly pageSize: _angular_core.ModelSignal<number>;
    /** The zero-based page index of the displayed list of items. Default is 0. */
    readonly pageIndex: _angular_core.ModelSignal<number>;
    /** An Observable that, when emitted, will reset the paginator to the first page. */
    readonly resetIndexFunc: _angular_core.InputSignal<Observable<any>>;
    /** The set of provided page size options to display to the user. */
    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
    /** Reference to the underlying MatPaginator instance. */
    readonly matPaginator: _angular_core.Signal<MatPaginator>;
    /** Event emitted when the paginator changes the page size or page index. */
    readonly pageChanged: _angular_core.OutputEmitterRef<{
        pageIndex: number;
        pageSize: number;
    }>;
    /** Subscription to the reset index observable. */
    private resetSub;
    /**
     * Initializes the component after content is initialized.
     * Sets up subscription to the reset index observable.
     */
    ngAfterContentInit(): void;
    /**
     * Cleans up resources when the component is destroyed.
     * Unsubscribes from the reset index observable.
     */
    ngOnDestroy(): void;
    /**
     * Handles page change events from the MatPaginator.
     * Updates the page index and page size, and emits the pageChanged event.
     * @param $event The page event from MatPaginator.
     */
    pageEvent($event: PageEvent): void;
    /**
     * Resets the paginator to the first page.
     * Updates both the component's page index and the underlying MatPaginator's page index.
     */
    reset(): void;
    /**
     * Calculates the actual index of an item in the full dataset based on its position in the current page.
     * @param inViewIndex The index of the item as it appears on the current page.
     * @returns The actual index of the item in the full dataset.
     */
    getActualIndex(inViewIndex: number): number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginatorComponent, "paginator", never, { "arrayLength": { "alias": "arrayLength"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "resetIndexFunc": { "alias": "resetIndexFunc"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; }, { "pageSize": "pageSizeChange"; "pageIndex": "pageIndexChange"; "pageChanged": "pageChanged"; }, never, never, true, never>;
}

interface ICountry {
    name: string;
    alpha2: string;
    alpha3: string;
    countryCode: string;
    'iso_3166-2': string;
    region: string;
    subRegion: string;
    intermediateRegion: string;
    regionCode: string;
    subRegionCode: string;
    intermediateRegionCode: string;
}
declare class PhoneNumberService {
    isoCountries: ICountry[];
    constructor();
    getByCode3(code: string): {
        name: string;
        alpha2: string;
        alpha3: string;
        countryCode: string;
        "iso_3166-2": string;
        region: string;
        subRegion: string;
        intermediateRegion: string;
        regionCode: string;
        subRegionCode: string;
        intermediateRegionCode: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneNumberService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PhoneNumberService>;
}

/**
 * Component for handling international phone number input with country code selection.
 * Extends InputBasicComponent to leverage common input functionality.
 */
declare class PhoneNumberComponent extends InputBasicComponent {
    /** Controls whether the input label is displayed. Default is true. */
    readonly showLabel: _angular_core.InputSignal<boolean>;
    /** Computed property that returns the country object based on the country code. */
    readonly country: _angular_core.Signal<ICountry>;
    /** Computed property that returns the lowercase alpha-2 country code. */
    protected readonly countryAlpha2: _angular_core.Signal<string>;
    /** Signal that holds the International Telephone Input (ITI) instance. */
    readonly iti: _angular_core.WritableSignal<Iti>;
    /** Input for the ISO 3166-1 alpha-3 country code. */
    readonly _countryCode3: _angular_core.InputSignal<string>;
    /**
     * Effect that updates the ITI country selection when the country code changes.
     * Also triggers form validation.
     */
    readonly countryCode3Effect: _angular_core.EffectRef;
    /**
     * Configuration options for the telephone input component.
     * Default settings disable dropdown and set Nigeria as initial country.
     */
    readonly _config: _angular_core.InputSignal<TelInputOptions>;
    /** Output event emitter that fires when a country is selected. */
    readonly onCountrySelect: _angular_core.OutputEmitterRef<{
        name?: string;
        iso2?: string;
        dialCode?: string;
        areaCodes?: string[];
        nationalPrefix?: string;
    }>;
    /** Reference to the phone number input element. */
    readonly pnRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
    /** Service for phone number operations and country data. */
    pnS: PhoneNumberService;
    /**
     * Computed configuration that merges the input config with country restrictions.
     * Limits available countries to the selected country if one is specified.
     */
    readonly config: _angular_core.Signal<{
        onlyCountries: string[];
        allowDropdown?: boolean;
        autoPlaceholder?: string;
        containerClass?: string;
        countryOrder?: string[];
        countrySearch?: boolean;
        customPlaceholder?: ((selectedCountryPlaceholder: string, selectedCountryData: object) => string) | null;
        dropdownContainer?: HTMLElement | null;
        excludeCountries?: string[];
        fixDropdownWidth?: boolean;
        formatAsYouType?: boolean;
        formatOnDisplay?: boolean;
        geoIpLookup?: ((success: (iso2: string) => void, failure: () => void) => void) | null;
        hiddenInput?: ((telInputName: string) => {
            phone: string;
            country?: string;
        }) | null;
        i18n?: intl_tel_input_i18n_types.I18n;
        initialCountry?: string;
        loadUtils?: () => Promise<{
            default: {
                formatNumber(number: string, iso2: string | undefined, format?: number): string;
                formatNumberAsYouType(number: string, iso2: string | undefined): string;
                getCoreNumber(number: string, iso2: string | undefined): string;
                getExampleNumber(iso2: string | undefined, nationalMode: boolean, numberType: number, useE164?: boolean): string;
                getExtension(number: string, iso2: string | undefined): string;
                getNumberType(number: string, iso2: string | undefined): number;
                getValidationError(number: string, iso2: string | undefined): number;
                isPossibleNumber(number: string, iso2: string | undefined, numberType?: ("FIXED_LINE_OR_MOBILE" | "FIXED_LINE" | "MOBILE" | "PAGER" | "PERSONAL_NUMBER" | "PREMIUM_RATE" | "SHARED_COST" | "TOLL_FREE" | "UAN" | "UNKNOWN" | "VOICEMAIL" | "VOIP")[] | null): boolean;
                isValidNumber(number: string, iso2: string | undefined, numberType?: ("FIXED_LINE_OR_MOBILE" | "FIXED_LINE" | "MOBILE" | "PAGER" | "PERSONAL_NUMBER" | "PREMIUM_RATE" | "SHARED_COST" | "TOLL_FREE" | "UAN" | "UNKNOWN" | "VOICEMAIL" | "VOIP")[] | null): boolean;
                numberFormat: {
                    NATIONAL: number;
                    INTERNATIONAL: number;
                    E164: number;
                    RFC3966: number;
                };
                numberType: object;
            };
        }>;
        nationalMode?: boolean;
        placeholderNumberType?: "FIXED_LINE_OR_MOBILE" | "FIXED_LINE" | "MOBILE" | "PAGER" | "PERSONAL_NUMBER" | "PREMIUM_RATE" | "SHARED_COST" | "TOLL_FREE" | "UAN" | "UNKNOWN" | "VOICEMAIL" | "VOIP";
        showFlags?: boolean;
        separateDialCode?: boolean;
        strictMode?: boolean;
        useFullscreenPopup?: boolean;
        validationNumberTypes?: ("FIXED_LINE_OR_MOBILE" | "FIXED_LINE" | "MOBILE" | "PAGER" | "PERSONAL_NUMBER" | "PREMIUM_RATE" | "SHARED_COST" | "TOLL_FREE" | "UAN" | "UNKNOWN" | "VOICEMAIL" | "VOIP")[] | null;
    }>;
    /**
     * Initializes the component by adding a custom validator to the form control.
     */
    ngOnInit(): void;
    /**
     * Lifecycle hook for after view initialization.
     */
    ngAfterViewInit(): void;
    /**
     * Callback for when the telephone input is initialized.
     * Stores the ITI instance for later use.
     *
     * @param e - The Intl-Tel-Input instance
     */
    telInputObject(e: Iti): void;
    /**
     * Updates the form control value when the phone number changes.
     *
     * @param e - The new phone number value
     */
    getNumber(e: any): void;
    /**
     * Custom validator that checks if the phone number is valid and matches the selected country.
     *
     * @param control - The form control to validate
     * @returns Validation errors object or null if valid
     */
    validate(control: AbstractControl): {
        custom: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneNumberComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneNumberComponent, "app-phone-number", never, { "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "_countryCode3": { "alias": "countryCode3"; "required": false; "isSignal": true; }; "_config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "onCountrySelect": "onCountrySelect"; }, never, never, true, never>;
}

/**
 * A rich text editor component using Quill editor
 * Provides text formatting, user mentions, and image handling capabilities
 */
declare class RichTextEditorComponent {
    /** Reference to the Quill editor component */
    editor: QuillEditorComponent;
    /** Whether the editor is enabled for editing */
    enabled: boolean;
    /**
     * Makes the editor non-editable and hides the toolbar
     * @param v - True to disable the editor, false to enable
     */
    set disabled(v: boolean);
    /**
     * Formgroup for the content
     */
    form: FormGroup;
    /**
     * Formcontrol name for the field
     */
    name: string;
    /**
     * Content when using ngModel
     */
    content: any;
    /**
     * Content change emission when using ngModel
     */
    contentChange: EventEmitter<any>;
    /** Array of users for mention functionality */
    users: {
        fullName: string;
        userName: string;
        code: string;
    }[];
    /** HTML string representation of the content */
    htmlString: any;
    /** Quill editor modules configuration */
    modules: QuillModules;
    constructor();
    /**
     * Initializes the component and sets up editor modules
     */
    ngOnInit(): void;
    /**
     * Function to search for users when mentioning
     * @param query - The search query string
     * @returns Observable of matching user objects
     */
    searchUsers: (query: string) => Observable<{
        userName?: string;
        fullName?: string;
    }[]>;
    /**
     * Sets the toolbar options and plugins for tagging users and resizing images
     */
    setModules(): void;
    /**
     * Enables the editor
     */
    enable: () => void;
    /**
     * Disables the editor
     */
    disable: () => void;
    /**
     * Handles content change events from the editor
     * @param e - The content change event
     */
    onContentChanged(e: ContentChange): void;
    /**
     * Gets the current content
     * @returns The current editor content
     */
    get getContent(): any;
    /**
     * Resets the editor content
     */
    reset: () => void;
    /**
     * Adds keyboard bindings to the Quill editor instance
     * @param quill - The Quill editor instance
     */
    addBindingCreated(quill: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorComponent, "rich-text-editor", never, { "enabled": { "alias": "enabled"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "form": { "alias": "form"; "required": false; }; "name": { "alias": "name"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, { "contentChange": "contentChange"; }, never, never, true, never>;
}

/**
 * Rich text editor component that integrates with Angular Reactive Forms.
 * Extends InputBasicComponent to provide form control functionality.
 *
 * @template TFormGroup - Type of the form group this component is part of
 * @template TControl - Type of the control value
 * @template TOption - Type of options for the component
 */
declare class RichTextEditorRFComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any, TControl = any, TOption = any> extends InputBasicComponent<TFormGroup, TControl, TOption> {
    /**
     * Handles content change events from the Quill editor.
     *
     * @param $event - The content change event from Quill
     * @returns Result of the input service's onContentChanged method
     */
    onContentChanged($event: ContentChange): void;
    /** Reference to the Quill editor component */
    editor: QuillEditorComponent;
    /** Array of users for the mention functionality */
    users: {
        fullName: string;
        userName: string;
        code: string;
    }[];
    /** HTML string representation of the editor content */
    htmlString: any;
    /**
     * Configuration for the Quill editor modules.
     * Includes settings for resize, syntax highlighting, mentions, and toolbar options.
     */
    modules: _angular_core.WritableSignal<QuillModules>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorRFComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorRFComponent<any, any, any>, "rich-text-editor-rf", never, {}, {}, never, never, true, never>;
}

/**
 * Component for displaying row action buttons in a grid or table.
 * Supports horizontal or vertical layouts, and various action types like add, delete, clone, and save.
 */
declare class RowActionsComponent {
    /** Emits when the add button is clicked */
    readonly clickedAdd: _angular_core.OutputEmitterRef<{
        btn: BtnComponent;
    }>;
    /** Emits when the delete button is clicked */
    readonly clickedDelete: _angular_core.OutputEmitterRef<{
        btn: BtnComponent;
    }>;
    /** Emits when the clone button is clicked */
    readonly clickedClone: _angular_core.OutputEmitterRef<{
        btn: BtnComponent;
    }>;
    /** Emits when the save button is clicked */
    readonly clickedSave: _angular_core.OutputEmitterRef<{
        btn: BtnComponent;
    }>;
    /** Additional custom buttons to display */
    readonly additionalBtns: _angular_core.InputSignal<IBtn[]>;
    /** Map of action types to help text */
    readonly helpMap: _angular_core.InputSignal<HelpMap>;
    /** Whether to display buttons in mini mode */
    readonly mini: _angular_core.InputSignal<boolean>;
    /** Whether to show the action buttons */
    readonly isShow: _angular_core.InputSignal<boolean>;
    /** Signal tracking vertical layout state */
    readonly isVertical: _angular_core.WritableSignal<boolean>;
    /** Signal tracking horizontal layout state */
    readonly isHorizontal: _angular_core.WritableSignal<boolean>;
    set _isVertical(v: boolean);
    set _isHorizontal(v: boolean);
    /** Whether to show the save button */
    readonly showSave: _angular_core.InputSignal<boolean>;
    /** Whether to show the clone button */
    readonly showClone: _angular_core.InputSignal<boolean>;
    /** Default action buttons */
    readonly btns: _angular_core.InputSignal<IBtn[]>;
    /** Configuration for the save button */
    protected saveBtn: IBtn;
    /** Configuration for the clone button */
    protected cloneBtn: IBtn;
    /**
     * Computed property that combines all buttons based on configuration
     * Includes default buttons, conditional save/clone buttons, and any additional buttons
     */
    readonly computedBtns: _angular_core.Signal<IBtn[]>;
    /** Initializes the component with horizontal layout by default */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowActionsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowActionsComponent, "row-actions", never, { "additionalBtns": { "alias": "additionalBtns"; "required": false; "isSignal": true; }; "helpMap": { "alias": "helpMap"; "required": false; "isSignal": true; }; "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "isShow": { "alias": "isShow"; "required": false; "isSignal": true; }; "_isVertical": { "alias": "isVertical"; "required": false; }; "_isHorizontal": { "alias": "isHorizontal"; "required": false; }; "showSave": { "alias": "showSave"; "required": false; "isSignal": true; }; "showClone": { "alias": "showClone"; "required": false; "isSignal": true; }; "btns": { "alias": "btns"; "required": false; "isSignal": true; }; }, { "clickedAdd": "clickedAdd"; "clickedDelete": "clickedDelete"; "clickedClone": "clickedClone"; "clickedSave": "clickedSave"; }, never, never, true, never>;
}
/**
 * Enum defining the types of actions available in row actions
 */
declare enum EActionType {
    add = "add",
    delete = "delete",
    clone = "clone",
    save = "save"
}
/**
 * Type defining a mapping between action types and their help text
 */
type HelpMap = {
    [typ in EActionType]?: string;
};

type SVGIconType = 'operations' | 'risk-modelling' | 'pricing' | 'valuation' | 'workflow' | 'finance' | 'report' | 'sales';

declare class SvgIconService {
    icons: Map<SVGIconType, string>;
    constructor();
    getSVG(icon: SVGIconType): {
        icon: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvgIconService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SvgIconService>;
}

declare class SvgIconComponent implements OnInit {
    svgIconS: SvgIconService;
    class: string;
    config: {
        color: string;
        onhover: string;
    };
    icon: string;
    set _icon(v: SVGIconType);
    iconRef: ElementRef<HTMLSpanElement>;
    constructor(svgIconS: SvgIconService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvgIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SvgIconComponent, "svg-icon", never, { "class": { "alias": "class"; "required": false; }; "_icon": { "alias": "icon"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Base directive that provides common functionality for native event listeners.
 * Handles event subscription, debouncing, and cleanup.
 */
declare abstract class BaseNativeEventListenerDirective {
    /**
     * Reference to the host element
     * @protected
     */
    protected readonly elementRef: ElementRef<HTMLElement>;
    /**
     * Destroy reference for automatic cleanup
     * @protected
     */
    protected readonly dr: DestroyRef;
    /**
     * Utility service for common operations
     * @protected
     */
    protected readonly uS: UtilityService<any>;
    /**
     * General delay in milliseconds to debounce events
     * @default 0
     */
    readonly nelDelay: _angular_core.ModelSignal<number>;
    /**
     * Custom event listener configuration
     */
    readonly nelQuery: _angular_core.InputSignal<NELQuery[]>;
    /**
     * Enable debug mode to log event details
     */
    readonly nelDebug: _angular_core.InputSignal<boolean>;
    /**
     * Query map generated from the consumer's query input
     * Uses the event field as the key
     * @protected
     */
    protected readonly nelQueryMap: _angular_core.Signal<{
        click?: NELQuery;
        mouseenter?: NELQuery;
        mouseleave?: NELQuery;
        pointermove?: NELQuery;
    }>;
    /**
     * Logger operator for debugging events
     * @param event - The event name
     * @param context - Optional context information
     * @returns RxJS operator that logs event details when debug is enabled
     * @protected
     */
    protected logger: <TEvent extends Event>(event: NELEventName, context?: string) => rxjs.MonoTypeOperatorFunction<TEvent>;
    /**
     * Maps raw events to NELEvent objects
     * @param eventName - The name of the event
     * @returns RxJS operator that transforms events
     * @protected
     */
    protected mapper: <TEvent extends Event>(eventName: any) => OperatorFunction<TEvent, NELEvent<TEvent>>;
    /**
     * Creates a chain of operators for processing events
     * @param eventName - The name of the event
     * @returns Array of RxJS operators for event processing
     * @protected
     */
    protected handler: <TEvent extends Event>(eventName: NELEventName) => [OperatorFunction<TEvent, TEvent>, OperatorFunction<TEvent, TEvent>, OperatorFunction<TEvent, TEvent>, OperatorFunction<TEvent, NELEvent<TEvent>>, OperatorFunction<NELEvent<TEvent>, NELEvent<TEvent>>];
    /**
     * Observable for mouse leave events
     */
    readonly mouseLeft$: Observable<MouseEvent>;
    /**
     * Map of active event subscriptions
     * @protected
     */
    protected eventTriggeredSubMap: {
        [eventName in NELEventName]?: Subscription;
    };
    /**
     * Sets up event handling for a specific event
     * @param eventName - The name of the event
     * @param eventHandler - The handler configuration
     * @param trigger$ - The observable that emits events
     * @protected
     */
    protected onTriggeredHandler: (eventName: NELEventName, eventHandler: NELEventHandler, trigger$: Observable<NELEvent>) => void;
    /**
     * Lifecycle hook that runs when the directive is initialized
     */
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseNativeEventListenerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseNativeEventListenerDirective, never, never, { "nelDelay": { "alias": "nelDelay"; "required": false; "isSignal": true; }; "nelQuery": { "alias": "nelQuery"; "required": false; "isSignal": true; }; "nelDebug": { "alias": "nelDebug"; "required": false; "isSignal": true; }; }, { "nelDelay": "nelDelayChange"; }, never, never, true, never>;
}
/**
 * Directive that listens for mouse enter events on the host element
 */
declare class MouseEnterListenerDirective extends BaseNativeEventListenerDirective {
    /**
     * Sets the handler for mouse enter events
     * @param v - The handler configuration
     */
    set nelMouseEntered(v: NELMouseEventHandler);
    /**
     * Tracks whether the mouse has left the element
     * @protected
     */
    protected left: boolean;
    /**
     * Observable that emits on mouse enter events
     */
    readonly mouseEnter$: Observable<NELEvent<MouseEvent>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MouseEnterListenerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MouseEnterListenerDirective, "[nelMouseEntered]", never, { "nelMouseEntered": { "alias": "nelMouseEntered"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that listens for mouse leave events on the host element
 */
declare class MouseLeaveListenerDirective extends BaseNativeEventListenerDirective {
    /**
     * Sets the handler for mouse leave events
     * @param v - The handler configuration
     */
    set nelMouseLeft(v: NELMouseEventHandler);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MouseLeaveListenerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MouseLeaveListenerDirective, "[nelMouseLeft]", never, { "nelMouseLeft": { "alias": "nelMouseLeft"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that listens for click events on the host element
 */
declare class MouseClickListenerDirective extends BaseNativeEventListenerDirective {
    /**
     * Observable that emits on click events
     */
    readonly clicked$: Observable<NELEvent<PointerEvent>>;
    /**
     * Sets the handler for click events
     * @param v - The handler configuration
     */
    set nelClicked(v: NELPointerEventHandler);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MouseClickListenerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MouseClickListenerDirective, "[nelClicked]", never, { "nelClicked": { "alias": "nelClicked"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that listens for pointer move events on the host element
 */
declare class PointerMoveListenerDirective extends BaseNativeEventListenerDirective {
    /**
     * Observable that emits on pointer move events
     */
    readonly pointerMoved$: Observable<NELEvent<PointerEvent>>;
    /**
     * Sets the handler for pointer move events
     * @param v - The handler configuration
     */
    set nelPointerMoved(v: NELPointerEventHandler);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PointerMoveListenerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PointerMoveListenerDirective, "[nelPointerMoved]", never, { "nelPointerMoved": { "alias": "nelPointerMoved"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Configuration for a native event listener
 */
interface NELQuery {
    /**
     * Optional delay in milliseconds to debounce the event
     */
    delay?: number;
    /**
     * The event to listen for
     */
    event: NELEventName;
}
/**
 * Represents a native event with its name
 * @template TEvent - The type of the event
 */
interface NELEvent<TEvent extends Event = Event> {
    /**
     * The event object
     */
    event: TEvent;
    /**
     * The name of the event
     */
    eventName: NELEventName;
}
/**
 * Enumeration of supported native event names
 */
declare enum NELEventName {
    click = "click",
    mouseEnter = "mouseenter",
    mouseLeave = "mouseleave",
    pointerMove = "pointermove"
}
/**
 * Handler configuration for native events
 * @template TEvent - The type of the event
 * @template TArg - The type of the optional argument
 */
type NELEventHandler<TEvent extends Event = Event, TArg = any> = {
    /**
     * Function to call when the event occurs
     * @param e - The event object
     * @param argument - Optional argument to pass to the action
     */
    action: (e: TEvent, argument?: TArg) => any;
    /**
     * Optional argument to pass to the action
     */
    argument?: TArg;
};
/**
 * Handler configuration for mouse events
 * @template TArg - The type of the optional argument
 */
type NELMouseEventHandler<TArg = any> = NELEventHandler<MouseEvent, TArg>;
/**
 * Handler configuration for pointer events
 * @template TArg - The type of the optional argument
 */
type NELPointerEventHandler<TArg = any> = NELEventHandler<PointerEvent, TArg>;
/**
 * Collection of all native event listener directives for easy import
 */
declare const NativeEventListenerDirectives: readonly [typeof MouseLeaveListenerDirective, typeof MouseClickListenerDirective, typeof MouseEnterListenerDirective, typeof PointerMoveListenerDirective];

/**
 * Service for handling reactive form inputs and form schema conversions.
 * @template TIFormSchema Type for form schema, defaults to IFormSchema
 * @template TFCInput Type for form control inputs, defaults to FCInput
 */
declare class ETSReactiveFormInputService<TIFormSchema = IFormSchema, TFCInput = FCInput> {
    constructor();
    /**
     * Converts an array of form control inputs to a controls object for FormGroup
     * @template TFCInput Type of form control inputs
     * @param inputs Array of form control inputs
     * @returns Object with control names as keys and AbstractControls as values
     */
    formFieldsFromFCInputsArr<TFCInput>(inputs: TFCInput[]): {
        [key: string]: AbstractControl<any, any, any>;
    };
    /**
     * Converts a form schema array to form controls object
     * @template TIFormSchema Type of form schema
     * @param formFields Array of form schema objects
     * @returns Object with field names as keys and FormControls as values
     */
    formSchemaToFormControls<TIFormSchema>(formFields: TIFormSchema[]): {
        [key: string]: AbstractControl<any, any, any>;
    };
    /**
     * Adds form controls from a form schema array to an existing FormGroup
     * @template TIFormSchema Type of form schema
     * @param formFields Array of form schema objects
     * @param form Existing FormGroup to add controls to
     * @returns Updated FormGroup with added controls
     */
    addFormSchemaToForm<TIFormSchema>(formFields: TIFormSchema[], form: FormGroup): FormGroup<any>;
    /**
     * Creates form controls from a plain object
     * @template T Type of the input object
     * @param obj Object with properties to convert to form controls
     * @returns Object with same keys as input and FormControls as values
     */
    formFieldsFromObj<T = any>(obj: T): { [key in keyof T]: AbstractControl<T[key], T[key], any>; };
    /**
     * Binds form controls from a FormGroup to an array of input objects
     * @template TFCInput Type of form control inputs
     * @param inputs Array of input objects to bind controls to
     * @param form FormGroup containing the controls to bind
     * @returns void
     */
    bindFormControlToInputs: <TFCInput_1>(inputs: TFCInput_1[], form: FormGroup) => void;
    /**
     * Converts a form schema to a FormGroup
     * @param schema Form schema definition
     * @param data Optional initial data
     * @returns FormGroup built from the schema
     */
    formSchemaToFormGroup: <T extends {
        [x: string]: any;
    }>(schema: IFormSchema[], data?: T) => FormGroup<IStrictFormGroup<T>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSReactiveFormInputService<any, any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSReactiveFormInputService<any, any>>;
}

/**
 * Base component for table functionality with selection, pagination, sorting, and customization options.
 * @template TItem The type of data items displayed in the table, must extend IObjectLiteral
 */
declare abstract class TableBaseComponent<TItem extends IObjectLiteral> {
    protected readonly cdr: ChangeDetectorRef;
    protected readonly reactiveFormInputService: ETSReactiveFormInputService<any, any>;
    /** Options for actions that can be performed on each row */
    readonly _rowOptions: _angular_core.InputSignal<IRowOption<TItem>[]>;
    /** Function that returns row-specific options based on the row data */
    readonly rowOptionsMap: _angular_core.InputSignal<(row: TItem) => (IRowOption<TItem> | null)[]>;
    /** Whether to center the content of table cells */
    readonly centerCells: _angular_core.InputSignal<boolean>;
    readonly enableRowClick: _angular_core.InputSignal<boolean>;
    /** Whether to apply rounded corners to the table */
    readonly curvy: _angular_core.InputSignal<boolean>;
    /** Whether to filter out duplicate rows */
    readonly distinct: _angular_core.InputSignal<boolean>;
    /** Text to display above the table */
    readonly header: _angular_core.InputSignal<string>;
    /** Whether rows can be expanded to show additional details */
    readonly isExpandable: _angular_core.InputSignal<boolean>;
    /** Label used for naming metadata like exported files */
    readonly label: _angular_core.InputSignal<string>;
    /** Function to determine if a row should be disabled */
    readonly isDisabledFunc: _angular_core.InputSignal<(row: TItem) => boolean>;
    /** Text to display when the table has no items */
    readonly noItemTxt: _angular_core.InputSignal<string>;
    /** Whether to prevent text wrapping in cells */
    readonly nowrap: _angular_core.InputSignal<boolean>;
    /** Whether to enable debug mode */
    readonly debug: _angular_core.InputSignal<boolean>;
    /** Template for expanded row content */
    readonly expandedRowTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Default sort direction */
    readonly orderDirection: _angular_core.InputSignal<SortType>;
    /** Default field to sort by */
    readonly orderField: _angular_core.InputSignal<keyof TItem>;
    /** Number of items to display per page */
    readonly pageSize: _angular_core.InputSignal<number>;
    /** Custom templates for specific columns */
    readonly customTemplates: _angular_core.InputSignal<{ [x in keyof TItem]?: TemplateRef<any>; }>;
    /** Template for content at the start of the table */
    readonly startSectionTemplate: _angular_core.InputSignal<TemplateRef<HTMLElement>>;
    /** Computed page size options based on results length */
    readonly computedPageSizeOptions: Signal<number[]>;
    /** Default page size options */
    readonly defaultPageSizeOptions: WritableSignal<number[]>;
    /** Custom page size options */
    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
    /** Whether to place selection checkboxes on the right side of the table */
    readonly placeSelectionAtRight: _angular_core.InputSignal<boolean>;
    /** Whether to show additional columns */
    readonly showAdditionalColumns: _angular_core.InputSignal<boolean>;
    /** Whether to show export functionality */
    readonly showExport: _angular_core.InputSignal<boolean>;
    /** Whether to use smaller font sizes */
    readonly smallerFonts: _angular_core.InputSignal<boolean>;
    /** Whether to apply striped styling to rows */
    readonly striped: _angular_core.InputSignal<boolean>;
    /** CSS class for the table container */
    readonly tableContainerClass: _angular_core.InputSignal<string>;
    /** Whether to enable row selection */
    readonly useSelection: _angular_core.InputSignal<boolean>;
    /** Event emitted when a row is expanded or collapsed */
    readonly clickedExpandRow: _angular_core.OutputEmitterRef<{
        open: boolean;
        row: TItem;
    }>;
    /** Form schema used to generate table columns */
    readonly formSchemaToColumns: _angular_core.InputSignal<IFormSchema<IStrictFormGroup<TItem>>[]>;
    /** Upload schema used to generate table columns */
    readonly uploadSchemaToColumns: _angular_core.InputSignal<{
        field?: keyof TItem;
        label?: string;
    }[]>;
    /** Raw column definitions */
    readonly _displayedColumns: _angular_core.InputSignal<TableCol<TItem>[]>;
    /** Filtered and formatted column definitions */
    readonly displayedColumns: Signal<TableCol<TItem>[]>;
    /**
     * Used to update the displayed columns through internal activities
     * like modification from Additional columns
     */
    readonly overrideDisplayedColumns: WritableSignal<TableCol<TItem>[]>;
    /** Columns that are not marked as Additional Columns and are not disabled */
    readonly presentableColumns: Signal<TableCol<TItem>[]>;
    readonly displayedColumnsMap: Signal<{
        [x: string]: TableCol<TItem>;
    }>;
    readonly computedDisplayedColumnsMap: Signal<{ [k in keyof TItem]: TableColFormatted<TItem>; }>;
    /** Computed and formatted column definitions */
    readonly computedDisplayedColumns: Signal<TableColFormatted<TItem>[]>;
    /** Event emitted when a row is clicked */
    readonly _rowClick: _angular_core.OutputEmitterRef<TItem>;
    /** Event emitted when a checkbox in the table is toggled */
    emitCheckbox: EventEmitter<{
        field: keyof TItem;
        item: TItem;
        value: boolean;
    }>;
    /** Reference to the paginator component */
    paginator?: MatPaginator;
    /** Reference to the sort component */
    sort?: MatSort;
    /** Reference to the table component */
    table: MatTable<any>;
    /** Total number of items in the dataset */
    readonly resultsLength: Signal<number>;
    /** CSS class for the starter section */
    protected readonly starterSectionClass: WritableSignal<string>;
    /** Raw column field names */
    readonly rawColumns: Signal<string[]>;
    /** Currently expanded element */
    readonly expandedElement: WritableSignal<TItem>;
    /** Selection model for managing selected rows */
    readonly selection: SelectionModel<TItem>;
    /** Signal for selection changes */
    protected _selectionChanged: Signal<SelectionChange<TItem>>;
    /** Signal for selected items */
    readonly selectedItemsSignal: Signal<any[] | TItem[]>;
    /** Output for selection changes */
    readonly selectionChanged: _angular_core.OutputRef<SelectionChange<TItem>>;
    /** Map of cell formatters by field name */
    protected readonly cellFormatterMap: {
        [k in keyof TItem]?: Partial<TableColFormatted<TItem>>;
    };
    /** Utility service */
    uS: UtilityService<any>;
    /** Table service */
    tS: TableService;
    /** Whether to use custom labels for columns */
    readonly useCustomLabels: _angular_core.ModelSignal<boolean>;
    /** Whether all rows are selected */
    readonly isAllSelected: Signal<boolean>;
    /** Whether any rows are selected */
    readonly isAnySelected: Signal<boolean>;
    /** Filtered row options */
    readonly rowOptions: Signal<IRowOption<TItem>[]>;
    /** Whether the table has row options */
    readonly hasRowOptions: Signal<boolean>;
    /**
     * Gets the label for the checkbox on a row
     * @param row The row to get the label for
     * @returns The checkbox label
     */
    checkboxLabel(row?: TItem): string;
    /**
     * Handles changes to the displayed fields
     * @param $event The event containing the new fields
     */
    fieldsChanged($event: {
        nFields: TableCol[];
        allFields: TableCol[];
    }): void;
    /**
     * Gets a callback function for updating action status
     * @param col The column containing the action
     * @returns A callback function
     */
    getActionStatusCallback(col: any): (state: boolean) => boolean;
    /** The data to display in the table */
    readonly data: WritableSignal<TItem[]>;
    /**
     * Processes columns to determine formatters and other properties
     * @param columns The columns to process
     */
    protected handleColumns: (columns: TableColFormatted<TItem>[]) => void;
    /**
     * Emits an event when a checkbox is toggled
     * @param field The field associated with the checkbox
     * @param item The row item
     * @param value The new checkbox value
     */
    outputCheckbox(field: keyof TItem, item: TItem, value: any): void;
    /** All available table columns, including those not currently displayed */
    readonly allTableColumns: Signal<TableCol<TItem>[]>;
    /**
     * Handles row click events
     * @param e The row that was clicked
     */
    rowClick(e: TItem): void;
    /** Gets the currently selected items */
    get selectedItems(): TItem[];
    /** Function to get row-specific options */
    readonly formOptionsMap: WritableSignal<(row: TItem) => IRowOption<TItem>[]>;
    /**
     * Extracts route information from a cell
     * @param cell The cell to extract route from
     * @param row The row containing the cell
     * @returns Route and query parameters
     */
    extractRoute: (cell: TableCol, row: TItem) => {
        route: string;
        queryParams: {};
    };
    /** Signal emitted after view initialization */
    readonly ngAfterViewInitSignal: WritableSignal<number>;
    /** Currently selected cell for expansion */
    readonly selectedCellForExpansion: WritableSignal<{
        column: TableCol;
        row: TItem;
    }>;
    /**
     * Expands a cell in a modal
     * @param row The row containing the cell
     * @param column The column of the cell
     * @param modal The modal component to use
     */
    expandCell(row: TItem, column: TableCol, modal: ModalComponent): void;
    /** Closes the currently expanded cell */
    closeExpandedCell(): void;
    /** Triggers change detection to refresh the UI */
    refreshUI(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableBaseComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableBaseComponent<any>, "ng-component", never, { "_rowOptions": { "alias": "rowOptions"; "required": false; "isSignal": true; }; "rowOptionsMap": { "alias": "rowOptionsMap"; "required": false; "isSignal": true; }; "centerCells": { "alias": "centerCells"; "required": false; "isSignal": true; }; "enableRowClick": { "alias": "enableRowClick"; "required": false; "isSignal": true; }; "curvy": { "alias": "curvy"; "required": false; "isSignal": true; }; "distinct": { "alias": "distinct"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "isExpandable": { "alias": "isExpandable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "isDisabledFunc": { "alias": "isDisabledFunc"; "required": false; "isSignal": true; }; "noItemTxt": { "alias": "noItemTxt"; "required": false; "isSignal": true; }; "nowrap": { "alias": "nowrap"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "expandedRowTemplate": { "alias": "expandedRowTemplate"; "required": false; "isSignal": true; }; "orderDirection": { "alias": "orderDirection"; "required": false; "isSignal": true; }; "orderField": { "alias": "orderField"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "customTemplates": { "alias": "customTemplates"; "required": false; "isSignal": true; }; "startSectionTemplate": { "alias": "startSectionTemplate"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "placeSelectionAtRight": { "alias": "placeSelectionAtRight"; "required": false; "isSignal": true; }; "showAdditionalColumns": { "alias": "showAdditionalColumns"; "required": false; "isSignal": true; }; "showExport": { "alias": "showExport"; "required": false; "isSignal": true; }; "smallerFonts": { "alias": "smallerFonts"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "tableContainerClass": { "alias": "tableContainerClass"; "required": false; "isSignal": true; }; "useSelection": { "alias": "useSelection"; "required": false; "isSignal": true; }; "formSchemaToColumns": { "alias": "formSchemaToColumns"; "required": false; "isSignal": true; }; "uploadSchemaToColumns": { "alias": "uploadSchemaToColumns"; "required": false; "isSignal": true; }; "_displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "useCustomLabels": { "alias": "useCustomLabels"; "required": false; "isSignal": true; }; }, { "clickedExpandRow": "clickedExpandRow"; "_rowClick": "rowClick"; "emitCheckbox": "emitCheckbox"; "selectionChanged": "selectionChanged"; "useCustomLabels": "useCustomLabelsChange"; }, never, never, true, never>;
}
/**
 * Extended TableCol with additional properties for hover functionality
 * @template TRow The type of data items displayed in the table
 */
declare class TableColFormatted<TRow> extends TableCol<TRow> {
    /** Function to handle mouse hover events */
    _onHoverFunction?: NELMouseEventHandler<TRow>['action'];
    /** Delay before triggering hover function in milliseconds */
    _onHoverDelay?: number;
}

/**
 * Component for displaying tabular data fetched via HTTP requests.
 * Extends TableBaseComponent to provide pagination, sorting, and filtering capabilities.
 *
 * @template TItem - The type of items displayed in the table
 */
declare class TableHttpsComponent<TItem = any> extends TableBaseComponent<TItem> implements OnInit {
    /**
     * Function that returns an Observable of table data when called with query parameters
     */
    readonly observableFunc: _angular_core.InputSignal<(data: any) => Observable<ITableSearchResp<TItem>>>;
    readonly observableFunc$: Observable<(data: any) => Observable<ITableSearchResp<TItem>>>;
    /**
     * Initial page number for the table (default: 0)
     */
    readonly pageNumber = 0;
    /**
     * Query data model for filtering the table
     */
    readonly queryData: _angular_core.ModelSignal<IObjectLiteral<any>>;
    /**
     * Whether to search even when no query parameters are provided
     */
    readonly searchIfNoQuery: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show the refresh button
     */
    readonly showRefreshBtn: _angular_core.InputSignal<boolean>;
    /**
     * Whether to use a static loader
     */
    readonly useStaticLoader: _angular_core.InputSignal<boolean>;
    /**
     * Computed property for the total number of results
     */
    readonly resultsLength: _angular_core.Signal<number>;
    /**
     * Form group for managing table state (pagination, sorting)
     */
    readonly form: FormGroup<{
        pageNumber: FormControl<number>;
        sortBy: FormControl<keyof TItem>;
        sortDirection: FormControl<"" | "DESC" | "ASC">;
        pageSize: FormControl<number>;
    }>;
    /**
     * Combines query data with form values
     */
    readonly allQueryData: _angular_core.Signal<{
        pageNumber: number;
        sortBy: keyof TItem;
        sortDirection: "" | "DESC" | "ASC";
        pageSize: number;
    }>;
    /**
     * Signal for the current form values
     */
    readonly formValue: _angular_core.Signal<{
        pageNumber: number;
        sortBy: keyof TItem;
        sortDirection: "" | "DESC" | "ASC";
        pageSize: number;
    }>;
    /**
     * Signal indicating whether data is currently being loaded
     */
    readonly isLoadingResults: WritableSignal<boolean>;
    /**
     * Determines if there are any active query parameters
     */
    readonly hasQuery: _angular_core.Signal<boolean>;
    /**
     * Determines if search should be allowed based on query parameters and settings
     */
    readonly allowSearch: _angular_core.Signal<boolean>;
    readonly allowSearch$: Observable<boolean>;
    /**
     * Filtered and paginated results for display
     */
    readonly filteredAndPagedResults: _angular_core.Signal<TItem[]>;
    route: ActivatedRoute;
    destroyRef: DestroyRef;
    readonly subs: {
        clear: () => void;
        push: (...subs: rxjs.Subscription[]) => number;
        subs: () => rxjs.Subscription[];
    };
    data: WritableSignal<TItem[]>;
    /**
     * Observable that fetches and processes search results
     */
    readonly searchResult$: Observable<{
        content: TItem[];
        total: number;
    }>;
    readonly searchResult: _angular_core.Signal<{
        content: TItem[];
        total: number;
    }>;
    /**
     * Output event emitted when data is fetched
     */
    readonly dataFetched: _angular_core.OutputRef<TItem[]>;
    /**
     * Text displayed in the search prompt
     */
    readonly searchPromptText: _angular_core.InputSignal<string>;
    /**
     * Initializes the component, setting up form values
     */
    ngOnInit(): void;
    /**
     * Sets up subscriptions after the view is initialized
     */
    ngAfterViewInit(): void;
    /**
     * Performs a search with the given query parameters
     * @param query - The query parameters to search with
     */
    search(query?: any): void;
    /**
     * Toggles selection of all rows in the current page
     */
    masterToggle(): void;
    /**
     * Resets pagination to the first page
     */
    resetPaging(): void;
    /**
     * Refreshes the table data
     */
    refresh(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableHttpsComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableHttpsComponent<any>, "table-https", never, { "observableFunc": { "alias": "observableFunc"; "required": false; "isSignal": true; }; "pageNumber": { "alias": "pageNumber"; "required": false; }; "queryData": { "alias": "queryData"; "required": false; "isSignal": true; }; "searchIfNoQuery": { "alias": "searchIfNoQuery"; "required": false; "isSignal": true; }; "showRefreshBtn": { "alias": "showRefreshBtn"; "required": false; "isSignal": true; }; "useStaticLoader": { "alias": "useStaticLoader"; "required": false; "isSignal": true; }; "searchPromptText": { "alias": "searchPromptText"; "required": false; "isSignal": true; }; }, { "queryData": "queryDataChange"; "dataFetched": "dataFetched"; }, never, never, true, never>;
}

/**
 * Component representing a row in a table with input capabilities.
 * Extends FormGeneratorComponent to provide form functionality within table rows.
 *
 * @template TFormGroup - The type of form group used in this row, must extend an object with AbstractControl properties
 */
declare class TableInputRowComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any> extends FormGeneratorComponent<TFormGroup, ITableInputFormSchema<TFormGroup>> {
    /** Event emitted when a row deletion is triggered */
    readonly onDeleteRowFunc: _angular_core.OutputEmitterRef<{
        btn?: BtnComponent;
    }>;
    /** Event emitted when a row addition is triggered */
    readonly onAddRowFunc: _angular_core.OutputEmitterRef<{
        btn?: BtnComponent;
    }>;
    /** Event emitted when an action button is clicked */
    readonly onActionButtonClick: _angular_core.OutputEmitterRef<{
        btn?: BtnComponent;
        actionButton: ITableInputBtn;
    }>;
    /** Controls whether the row is in show/display mode */
    readonly isShow: _angular_core.InputSignal<boolean>;
    /** Controls whether to hide the add button */
    readonly hideAdd: _angular_core.InputSignal<boolean>;
    /** Controls whether to hide the delete button */
    readonly hideDelete: _angular_core.InputSignal<boolean>;
    /** Controls whether inputs should have borders */
    readonly borderedInput: _angular_core.InputSignal<boolean>;
    /** List of action buttons to display in the row */
    readonly actionBtns: _angular_core.InputSignal<ITableInputBtn[]>;
    /**
     * Map of child form schemas for nested form structures
     * Keys correspond to form control names in TFormGroup
     */
    readonly childrenFormSchemaMap: _angular_core.InputSignal<{ [k in keyof TFormGroup]?: {
        formSchema: IFormSchema[];
        formSchemaStr: string[];
    }; }>;
    /**
     * Effect that disables the form when isShow is true
     * This prevents editing when in display/view mode
     */
    readonly isShowEffect: _angular_core.EffectRef;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableInputRowComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableInputRowComponent<any>, "tr[table-input-row]", never, { "isShow": { "alias": "isShow"; "required": false; "isSignal": true; }; "hideAdd": { "alias": "hideAdd"; "required": false; "isSignal": true; }; "hideDelete": { "alias": "hideDelete"; "required": false; "isSignal": true; }; "borderedInput": { "alias": "borderedInput"; "required": false; "isSignal": true; }; "actionBtns": { "alias": "actionBtns"; "required": false; "isSignal": true; }; "childrenFormSchemaMap": { "alias": "childrenFormSchemaMap"; "required": false; "isSignal": true; }; }, { "onDeleteRowFunc": "onDeleteRowFunc"; "onAddRowFunc": "onAddRowFunc"; "onActionButtonClick": "onActionButtonClick"; }, never, never, true, never>;
}

/**
 * Angular pipe that paginates an array by slicing it based on page size and page index.
 *
 * @example
 * ```html
 * <div *ngFor="let item of items | paginator:10:currentPage:items.length">
 *   {{ item }}
 * </div>
 * ```
 */
declare class PaginatorPipe implements PipeTransform {
    /**
     * Transforms an array by paginating it based on the specified page size and page index.
     *
     * @param arr - The array to be paginated
     * @param pageSize - The number of items to display per page
     * @param pageIndex - The zero-based index of the current page
     * @param arrayLength - Optional parameter to force pipe re-evaluation when array length changes
     * @returns A slice of the original array containing only the items for the current page
     *
     * @typeParam T - The type of elements in the array
     */
    transform<T>(arr: T[], pageSize: number, pageIndex: number, arrayLength?: number): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<PaginatorPipe, "paginator", true>;
}

/**
 * Table Input Component
 *
 * A component that renders a table with input fields, supporting filtering, pagination,
 * and row actions like add/delete.
 *
 * @template TFormGroup The type of form group used for each row in the table
 */
declare class TableInputComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any> extends FormGeneratorComponent<TFormGroup, ITableInputFormSchema<TFormGroup>> implements OnInit {
    /**
     * Logs column configuration to console
     * @param _t20 The form schema to log
     */
    logColumn(_t20: ITableInputFormSchema<TFormGroup>): void;
    /** The form array containing all row form groups */
    readonly formArray: _angular_core.InputSignal<FormArray<FormGroup<TFormGroup>>>;
    /** CSS class for the filter container */
    readonly filterContainerClass: _angular_core.InputSignal<string>;
    /** Function to determine CSS class for a row based on its data */
    readonly classFunction: _angular_core.InputSignal<(row: any) => string>;
    /** Whether to show borders around the table */
    readonly border: _angular_core.InputSignal<boolean>;
    /** Whether to prevent text wrapping in table cells */
    readonly noWrap: _angular_core.InputSignal<boolean>;
    /** Whether to use partial matching for filters */
    readonly filterLikeMatch: _angular_core.InputSignal<boolean>;
    /** Whether to use exact matching for filters (inverse of filterLikeMatch) */
    readonly filterExactMatch: _angular_core.Signal<boolean>;
    /** Whether to show the table */
    readonly isShow: _angular_core.InputSignal<boolean>;
    /**
     * Sets the page size for pagination
     * @param v The number of items per page
     */
    set _pageSize(v: number);
    /** The number of items to display per page */
    readonly pageSize: _angular_core.WritableSignal<number>;
    /** Current pagination state */
    readonly pageState: _angular_core.WritableSignal<{
        pageIndex: number;
        pageSize: number;
    }>;
    /** Action buttons to display for each row */
    readonly actionBtns: _angular_core.InputSignal<ITableInputBtn[]>;
    /**
     * Sets the form schema for the table
     * @param v Array of form schema definitions
     */
    set _formSchema(v: ITableInputFormSchema<TFormGroup>[]);
    /** The form structure for a single row */
    singleFormStructure: FormGroup<TFormGroup>;
    /**
     * Function to call when deleting a row
     * Leave empty if you don't want the delete button to show
     */
    deleteRowFunc: (index: number, data?: FormGroup<TFormGroup>['value'], config?: {
        btn: BtnComponent;
    }) => any;
    /**
     * Function to call when adding a row
     * Leave empty if you don't want the add button to show
     */
    addRowFunc: (index: number, data?: FormGroup<TFormGroup>['value']) => any;
    /** Whether to hide the delete button */
    readonly hideDelete: _angular_core.InputSignal<boolean>;
    /** Whether to hide the add button */
    readonly hideAdd: _angular_core.InputSignal<boolean>;
    /** Whether to show borders around input fields */
    readonly borderedInput: _angular_core.InputSignal<boolean>;
    /** CSS class for input fields based on borderedInput setting */
    readonly inputClass: _angular_core.Signal<string>;
    /**
     * Sets whether to use pagination
     * @param v Whether pagination is enabled
     */
    set _usePaginator(v: boolean);
    /** CSS class for the table element */
    readonly tableClass: _angular_core.InputSignal<string>;
    /** Form schema fields that are used for searching/filtering */
    protected readonly filterFormschema: _angular_core.Signal<IFormSchema<any>[]>;
    /** Form group for filter controls */
    protected readonly filterForm: _angular_core.Signal<FormGroup<{}>>;
    /** Whether to use pagination */
    protected readonly usePaginator: _angular_core.WritableSignal<boolean>;
    /** Map of child form schemas for nested structures */
    protected childrenFormSchemaMap: {
        [k in keyof TFormGroup]?: {
            formSchema: ITableInputFormSchema[];
            formSchemaStr: string[];
        };
    };
    /** Value used to trigger refresh */
    refresher: number;
    /** Subscription for form array pagination */
    formArrayPaginationSub: Subscription;
    /** Reference to the paginator component */
    paginatorComponent: PaginatorComponent;
    /** Observable of the filter form */
    readonly filterForm$: Observable<FormGroup<{}>>;
    /** Signal of the current filter form values */
    readonly filterFormValueSignal: _angular_core.Signal<Partial<{}>>;
    /** Signal of the form array length */
    readonly formArrayLengthSignal: _angular_core.Signal<number>;
    /** Form array with index information */
    readonly formArrayIndexed: _angular_core.Signal<{
        index: number;
        form: FormGroup<TFormGroup>;
        id: string;
    }[]>;
    /** Form array filtered according to search criteria */
    readonly filteredFormArray: _angular_core.Signal<{
        index: number;
        form: FormGroup<TFormGroup>;
        id: string;
    }[]>;
    /** Form array after both filtering and pagination */
    readonly paginatedAndFilteredFormArray: _angular_core.Signal<{
        index: number;
        form: FormGroup<TFormGroup>;
        id: string;
    }[]>;
    /** Length of the filtered form array */
    readonly filteredFormArrayLength: _angular_core.Signal<number>;
    /** Utility service for common functions */
    utilityService: UtilityService<any>;
    /** Pipe for filtering form array groups */
    filterFormArrayGroupPipe: FilterFormArrayGroupPipe;
    /** Pipe for pagination */
    paginatorPipe: PaginatorPipe;
    /**
     * Initializes the component
     */
    ngOnInit(): void;
    /**
     * Performs actions after view initialization
     */
    ngAfterViewInit(): void;
    /**
     * Refreshes the component display
     */
    refresh(): void;
    /**
     * Cleans up subscriptions when component is destroyed
     */
    onDestroy(): void;
    /**
     * Handles pagination events
     * @param $event The pagination event containing pageIndex and pageSize
     */
    pageChanged($event: {
        pageIndex: number;
        pageSize: number;
    }): void;
    /**
     * Resets the paginator to the first page
     */
    resetPaginator(): void;
    /**
     * Pre-processes form schema items before initialization
     * @param items Array of form schema items to format
     */
    protected preFormatFormSchema: (items: ITableInputFormSchema<TFormGroup>[]) => void;
    /**
     * Initializes the component with the provided schema
     * @param schema Array of form schema definitions
     */
    init(schema: ITableInputFormSchema<TFormGroup>[]): void;
    /**
     * Handles clicks on action buttons
     * @param index The row index
     * @param form The form group for the row
     * @param e Event data containing the button and action
     */
    handleActionButtonClick(index: number, form: FormGroup<TFormGroup>, e: {
        btn?: BtnComponent;
        actionButton: ITableInputBtn;
    }): void;
    /**
     * Handles row deletion
     * @param index The index of the row to delete
     * @param rowForm The form group for the row
     * @param config Optional configuration
     */
    deleteRowClicked: (index: number, rowForm: FormGroup<TFormGroup>, config?: {
        btn: BtnComponent;
    }) => void;
    /**
     * Handles row addition
     * @param index The index where the new row should be inserted
     */
    addRowClicked: (index: number) => void;
    /**
     * Checks and logs required fields in the form structure
     */
    checkRequiredFields: () => void;
    /**
     * Processes an individual form schema item
     * @param scheme The form schema item to process
     */
    handleFormScheme(scheme: ITableInputFormSchema): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableInputComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableInputComponent<any>, "table-input", never, { "formArray": { "alias": "formArray"; "required": false; "isSignal": true; }; "filterContainerClass": { "alias": "filterContainerClass"; "required": false; "isSignal": true; }; "classFunction": { "alias": "classFunction"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; "noWrap": { "alias": "noWrap"; "required": false; "isSignal": true; }; "filterLikeMatch": { "alias": "filterLikeMatch"; "required": false; "isSignal": true; }; "isShow": { "alias": "isShow"; "required": false; "isSignal": true; }; "_pageSize": { "alias": "pageSize"; "required": false; }; "actionBtns": { "alias": "actionBtns"; "required": false; "isSignal": true; }; "_formSchema": { "alias": "formSchema"; "required": true; }; "singleFormStructure": { "alias": "singleFormStructure"; "required": true; }; "deleteRowFunc": { "alias": "deleteRowFunc"; "required": false; }; "addRowFunc": { "alias": "addRowFunc"; "required": false; }; "hideDelete": { "alias": "hideDelete"; "required": false; "isSignal": true; }; "hideAdd": { "alias": "hideAdd"; "required": false; "isSignal": true; }; "borderedInput": { "alias": "borderedInput"; "required": false; "isSignal": true; }; "_usePaginator": { "alias": "usePaginator"; "required": false; }; "tableClass": { "alias": "tableClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Pipe that applies a class function to a form group
 * Returns the CSS class based on the form data
 */
declare class TableInputClassFunctionPipe implements PipeTransform {
    /** Subscription to form value changes */
    sub: Subscription;
    /**
     * Transforms a form group using a class function
     * @param form The form group to transform
     * @param classFunction Function that determines the CSS class based on form data
     * @returns Observable of the CSS class string
     */
    transform(form: FormGroup, classFunction?: (row: any) => string): Observable<string>;
    /**
     * Cleans up subscriptions when pipe is destroyed
     */
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableInputClassFunctionPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TableInputClassFunctionPipe, "tableInputClassFunction", true>;
}

/**
 * A component that displays data in a plain table format with optional filtering, pagination, and row selection.
 * Extends TableBaseComponent to provide common table functionality.
 *
 * @template TItem - The type of data items displayed in the table
 */
declare class TablePlainComponent<TItem = any> extends TableBaseComponent<TItem> implements OnInit {
    /** Signal containing the data to be displayed in the table */
    readonly data: _angular_core.WritableSignal<TItem[]>;
    /** Custom CSS class to apply to row selection checkboxes */
    readonly customSelectClass: _angular_core.InputSignal<string>;
    /** Field name to use as the unique identifier for each row (defaults to 'id') */
    readonly idField: _angular_core.InputSignal<string>;
    /** Observable data source that can be used instead of direct data input */
    readonly obsDataSource: _angular_core.InputSignal<Observable<TItem[]>>;
    /** Whether to show the filter controls */
    readonly showFilter: _angular_core.InputSignal<boolean>;
    /** Whether to show pagination controls */
    readonly showPager: _angular_core.InputSignal<boolean>;
    /** Function to determine if a row should have selection disabled */
    disableSelectionByField: (x: any) => boolean;
    /** Event emitted when a row is viewed */
    _view: EventEmitter<any>;
    /** Event emitted when the data changes */
    dataChanged: EventEmitter<any>;
    /** Event emitted when the filter criteria change */
    filterChange: EventEmitter<any>;
    /** Event emitted when the list data is modified */
    listMutated: EventEmitter<TItem[]>;
    /** Computed value for the total number of results */
    readonly resultsLength: _angular_core.Signal<number>;
    /** Options for cell rendering */
    readonly cellOptions: IFormOptions;
    /** Map for transforming filter values */
    protected readonly filterValueTransformationMap: {
        [value: string]: string;
    };
    /**
     * Computed MatTableDataSource based on the current data and filter settings
     */
    readonly dataSource: _angular_core.Signal<MatTableDataSource<TItem, _angular_material_paginator.MatPaginator>>;
    /** Stores the default filter predicate function */
    defaultFilterPredicate: any;
    /** Whether to use exact matching for filtering (vs. substring matching) */
    readonly filterExactMatch: _angular_core.InputSignal<boolean>;
    /** Computed value that determines if filtering should use substring matching */
    readonly filterLikeMatch: _angular_core.Signal<boolean>;
    /** Schema definitions for filter fields */
    readonly filterFields: _angular_core.WritableSignal<IFormSchema<any>[]>;
    /** Computed options for filter dropdown based on displayed columns */
    readonly filterOptions: _angular_core.Signal<ICodeDescription[]>;
    /** Form group for filter controls */
    readonly filterForm: FormGroup<{
        field: FormControl<any>;
        value: FormControl<any>;
    }>;
    /**
     * Input setter for the data to be displayed in the table
     * @param v - Array of data items
     */
    set _data(v: TItem[]);
    /**
     * Input setter for filter field definitions
     * @param v - Array of form schema definitions for filter fields
     */
    set _filterFields(v: IFormSchema[]);
    /**
     * Input setter for filter fields defined as a map
     * @param v - Map of field names to form schema definitions
     */
    set _filterFieldsMap(v: {
        [x: string]: IFormSchema;
    });
    /** Whether selection should apply only to the current page (true) or all data (false) */
    selectionPerPage: boolean;
    /** Signal for the current filter form values */
    readonly filterFormSignal: _angular_core.Signal<{
        field: string;
        value: string;
    }>;
    constructor();
    /** Angular lifecycle hook for component initialization */
    ngOnInit(): void;
    /** Angular lifecycle hook called after the view is initialized */
    ngAfterViewInit(): void;
    /**
     * Clears all filter values and refreshes the UI
     */
    clearFilter(): void;
    /**
     * Handles checkbox output for a specific field in an item
     * @param field - The field to update
     * @param item - The data item being modified
     * @param value - The new value
     * @returns The result from the parent class implementation
     */
    outputCheckbox(field: keyof TItem, item: TItem, value: any): void;
    /**
     * Toggles selection of all rows in the current page or all data
     * If all applicable rows are selected, this will clear the selection
     */
    masterToggle(): void;
    /**
     * Handler for filter change events
     * @param e - The filter change event
     */
    onFilterChange(e: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablePlainComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TablePlainComponent<any>, "table-plain", never, { "customSelectClass": { "alias": "customSelectClass"; "required": false; "isSignal": true; }; "idField": { "alias": "idField"; "required": false; "isSignal": true; }; "obsDataSource": { "alias": "obsDataSource"; "required": false; "isSignal": true; }; "showFilter": { "alias": "showFilter"; "required": false; "isSignal": true; }; "showPager": { "alias": "showPager"; "required": false; "isSignal": true; }; "disableSelectionByField": { "alias": "disableSelectionByField"; "required": false; }; "filterExactMatch": { "alias": "filterExactMatch"; "required": false; "isSignal": true; }; "_data": { "alias": "data"; "required": false; }; "_filterFields": { "alias": "filterFields"; "required": false; }; "_filterFieldsMap": { "alias": "filterFieldsMap"; "required": false; }; "selectionPerPage": { "alias": "selectionPerPage"; "required": false; }; }, { "_view": "view"; "dataChanged": "dataChanged"; "filterChange": "filterChange"; "listMutated": "listMutated"; }, never, never, true, never>;
}

/**
 * Pipe that formats table column data based on the column configuration.
 * Applies formatter functions if defined in the column configuration.
 */
declare class GetColFormattedPipe implements PipeTransform {
    /**
     * Transforms the row data for a specific column using formatters if available.
     * @param row - The data row object
     * @param col - The column configuration
     * @returns An observable containing the formatted value
     */
    transform(row: any, col: TableCol): rxjs.Observable<any> | Promise<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetColFormattedPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetColFormattedPipe, "getColFormatted", true>;
}
/**
 * Pipe that formats expanded table column data based on the column configuration.
 * Used for expanded row views.
 */
declare class GetColFormattedEPipe implements PipeTransform {
    /**
     * Transforms the expanded row data for a specific column using formatters if available.
     * @param row - The data row object
     * @param col - The column configuration
     * @returns An observable containing the formatted value
     */
    transform(row: any, col: TableCol): rxjs.Observable<any> | Promise<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetColFormattedEPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetColFormattedEPipe, "getColFormattedE", true>;
}
/**
 * Pipe that extracts raw field values from table data.
 */
declare class GetRawFieldsPipe implements PipeTransform {
    /** Injected table service */
    service: TableService;
    /** Transform method delegated to the service's getRawFields method */
    transform: (arr: TableCol[], hasOptions: boolean, useSelection?: boolean, placeSelectionAtRight?: boolean, isExpandable?: boolean) => string[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetRawFieldsPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetRawFieldsPipe, "getRawFields", true>;
}
/**
 * Pipe that extracts header titles from column configurations.
 */
declare class GetHeadersPipe implements PipeTransform {
    /**
     * Extracts the title property from each column configuration.
     * @param arr - Array of column configurations
     * @returns Array of column titles
     */
    transform(arr: TableCol[]): string[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetHeadersPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetHeadersPipe, "getHeaders", true>;
}
/**
 * Pipe that converts table data to a formatted string representation.
 * Useful for exporting or displaying table data as text.
 */
declare class TableToStringPipe implements PipeTransform {
    cfS: GetColFormattedPipe;
    /**
     * Transforms table data into a string representation.
     * @param arr - Array of column configurations
     * @param obj - The data object to format
     * @returns Promise resolving to a formatted string representation of the table data
     */
    transform(arr: TableCol[], obj: any): Promise<string>;
    /**
     * @param cfS - Injected GetColFormattedPipe for formatting column values
     */
    constructor(cfS: GetColFormattedPipe);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableToStringPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TableToStringPipe, "tableToString", true>;
}
/**
 * Module that bundles all table-related pipes for easy import.
 */
declare class TablePipesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablePipesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TablePipesModule, never, [typeof i1$1.CommonModule, typeof GetColFormattedPipe, typeof GetHeadersPipe, typeof GetRawFieldsPipe, typeof TableToStringPipe, typeof GetColFormattedEPipe], [typeof GetColFormattedPipe, typeof GetHeadersPipe, typeof GetRawFieldsPipe, typeof TableToStringPipe, typeof GetColFormattedEPipe]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TablePipesModule>;
}

/**
 * A vertical navigation component that provides a side navigation drawer with nested menu items.
 * Supports customizable toolbar, drawer mode, and nested menu items with tree structure.
 */
declare class VerticalNavComponent {
    /** Utility service for common functionality */
    uS: UtilityService<any>;
    /** Router service for navigation */
    router: Router;
    /** Function to determine whether a child node should be shown */
    readonly shouldShowChildInput: _angular_core.InputSignal<(_: number, node: IMenuItem) => boolean>;
    /** Computed function that returns shouldShowChildInput or a default function that always returns true */
    readonly shouldShowChild: _angular_core.Signal<(_: number, node: IMenuItem) => boolean>;
    /** Title displayed in the toolbar */
    readonly toolbarTitle: _angular_core.InputSignal<string>;
    /** Mode of the drawer: 'over', 'push', or 'side' */
    readonly drawerMode: _angular_core.InputSignal<MatDrawerMode>;
    /** Whether the drawer is initially opened */
    readonly opened: _angular_core.InputSignal<boolean>;
    /** URL or path to the logo displayed in the toolbar */
    readonly toolbarLogo: _angular_core.InputSignal<string>;
    /** Custom styles for the toolbar logo */
    readonly toolbarLogoStyle: _angular_core.InputSignal<IObjectLiteral<any>>;
    /** Gap between the top of the page and the fixed toolbar */
    readonly fixedTopGap: _angular_core.InputSignal<number>;
    /** Custom template for the sidenav content */
    readonly sidenavTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Custom template for the toolbar */
    readonly toolbarTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Custom template for the end section of the toolbar (only works when toolbarTemplate is not set) */
    readonly toolbarEndTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Custom template for the main body content */
    readonly bodyTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Whether to display the toolbar */
    readonly useToolbar: _angular_core.InputSignal<boolean>;
    /** Whether to display a toolbar in the body section */
    readonly useBodyToolbar: _angular_core.InputSignal<boolean>;
    /** Whether to show the menu */
    readonly showMenu: _angular_core.InputSignal<boolean>;
    /** Array of menu items to display in the navigation */
    readonly menuItems: _angular_core.InputSignal<IMenuItem[]>;
    /** Data source for the nested tree of menu items */
    readonly dataSource: _angular_core.Signal<MatTreeNestedDataSource<IMenuItem>>;
    /** Computed drawer mode based on input or device size */
    readonly computedDrawerMode: _angular_core.Signal<MatDrawerMode>;
    /** Computed opened state based on input, device size, and showMenu setting */
    readonly computedOpened: _angular_core.Signal<boolean>;
    /** Unique ID for the mat-sidenav element */
    readonly id: _angular_core.WritableSignal<string>;
    /** Tree control for handling the expansion/collapse of nested menu items */
    readonly treeControl: _angular_core.WritableSignal<NestedTreeControl<IMenuItem, IMenuItem>>;
    /** Reference to the MatDrawer component */
    readonly drawer: _angular_core.Signal<MatDrawer>;
    /** Reference to the toolbar container element */
    readonly toolbarContRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
    constructor();
    /**
     * Initializes the perfect-scrollbar for the drawer container after the view is initialized
     */
    ngAfterViewInit(): void;
    /**
     * Toggles the side menu drawer open/closed state
     */
    toggleSideMenu(): void;
    /**
     * Function to determine if a node has child nodes that should be displayed
     */
    readonly hasChild: _angular_core.WritableSignal<(_: number, node: IMenuItem) => boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VerticalNavComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VerticalNavComponent, "vertical-nav", never, { "shouldShowChildInput": { "alias": "shouldShowChildInput"; "required": false; "isSignal": true; }; "toolbarTitle": { "alias": "toolbarTitle"; "required": false; "isSignal": true; }; "drawerMode": { "alias": "drawerMode"; "required": false; "isSignal": true; }; "opened": { "alias": "opened"; "required": false; "isSignal": true; }; "toolbarLogo": { "alias": "toolbarLogo"; "required": false; "isSignal": true; }; "toolbarLogoStyle": { "alias": "toolbarLogoStyle"; "required": false; "isSignal": true; }; "fixedTopGap": { "alias": "fixedTopGap"; "required": false; "isSignal": true; }; "sidenavTemplate": { "alias": "sidenavTemplate"; "required": false; "isSignal": true; }; "toolbarTemplate": { "alias": "toolbarTemplate"; "required": false; "isSignal": true; }; "toolbarEndTemplate": { "alias": "toolbarEndTemplate"; "required": false; "isSignal": true; }; "bodyTemplate": { "alias": "bodyTemplate"; "required": false; "isSignal": true; }; "useToolbar": { "alias": "useToolbar"; "required": false; "isSignal": true; }; "useBodyToolbar": { "alias": "useBodyToolbar"; "required": false; "isSignal": true; }; "showMenu": { "alias": "showMenu"; "required": false; "isSignal": true; }; "menuItems": { "alias": "menuItems"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
/**
 * Interface representing a menu item in the vertical navigation
 */
interface IMenuItem {
    /** Display text for the menu item */
    label?: string;
    /** Router link for navigation */
    link?: string;
    /** Function to execute when the menu item is clicked */
    action?: (item: IMenuItem) => any;
    /** Icon to display with the menu item */
    icon?: string;
    /** Nesting level of the menu item */
    level?: number;
    /** Unique identifier for the menu item */
    id?: string;
    /** Query parameters for the router link */
    queryParams?: IObjectLiteral;
    /** Submenu items */
    subs?: IMenuItem[];
}

declare class TextAreaModalComponent implements OnInit {
    dialogRef: MatDialogRef<TextAreaModalComponent>;
    data: {
        showLength: boolean;
        label: string;
        value: string;
        isShow: boolean;
    };
    _data: {
        label: string;
        value: string;
    };
    constructor(dialogRef: MatDialogRef<TextAreaModalComponent>, data: {
        showLength: boolean;
        label: string;
        value: string;
        isShow: boolean;
    });
    ngOnInit(): void;
    close(): void;
    save(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextAreaModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextAreaModalComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class TextAreaModalService {
    dialog: MatDialog;
    constructor(dialog: MatDialog);
    openTextAreaModal: (label: string, value: string, isShow: boolean, showLength: boolean) => _angular_material_dialog.MatDialogRef<TextAreaModalComponent, any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextAreaModalService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TextAreaModalService>;
}

/**
 * A component for displaying text with various formatting options and behaviors.
 * Supports actions, formatting, icons, and styling customizations.
 */
declare class TextCase1Component implements OnInit {
    /** Action to be performed when the component is clicked */
    action: any;
    /** Custom formatter function for the value display */
    formatter: (item: any) => string | Promise<string> | Observable<string>;
    /** Tooltip text to display on hover */
    hint: string;
    /** Icon class to display alongside the text */
    icon: string;
    /**
     * Sets whether the component is editable
     * When true, automatically sets the icon to a pencil
     */
    set editable(v: boolean);
    /** Whether to invert the color scheme */
    inverted: boolean;
    /** Label text to display */
    lbl: string;
    /** CSS class for the label */
    lblClass: string;
    /** Whether to use light styling */
    light: boolean;
    /** Additional CSS class for the main component */
    mclass: string;
    /** Custom NgStyle object for the value element */
    valueNGStyle: {
        [x: string]: any;
    };
    /** Route to navigate to when clicked */
    route: string;
    /** Whether to use small text size */
    small: boolean;
    /** Whether to stack label and value vertically */
    stacked: boolean;
    /** The value to display */
    val: any;
    /** Whether to use extra small text size */
    xsmall: boolean;
    constructor();
    /**
     * Lifecycle hook that is called after data-bound properties are initialized
     */
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextCase1Component, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextCase1Component, "text-case-1", never, { "action": { "alias": "action"; "required": false; }; "formatter": { "alias": "formatter"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; }; "lbl": { "alias": "lbl"; "required": false; }; "lblClass": { "alias": "lblClass"; "required": false; }; "light": { "alias": "light"; "required": false; }; "mclass": { "alias": "mclass"; "required": false; }; "valueNGStyle": { "alias": "valueNGStyle"; "required": false; }; "route": { "alias": "route"; "required": false; }; "small": { "alias": "small"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "val": { "alias": "val"; "required": false; }; "xsmall": { "alias": "xsmall"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Service for handling text case formatting operations.
 * Provides utilities to format text values using custom formatters.
 */
declare class TextCaseService {
    constructor();
    /**
     * Formats a value using the provided formatter function or returns the original value.
     *
     * @param item - The item containing the value to format and the formatter function
     * @param item.value - The value to be formatted
     * @param item.formatter - Optional formatter function that can return a string, Promise<string>, or Observable<string>
     * @returns An Observable containing either the formatted value or the original value if no formatter is provided
     */
    handleValueFormatter: (item: {
        value: any;
        formatter: ((item?: any) => string | Promise<string> | Observable<string>) | undefined;
    }) => Observable<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextCaseService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TextCaseService>;
}

/**
 * A flexible component for displaying text data with various formatting options.
 * Supports different display types, formatting, routing, and styling configurations.
 * @template T The type of data object being displayed
 */
declare class TextCase2Component<T = any> {
    /**
     * Function to be called when the component is interacted with
     */
    readonly action: _angular_core.InputSignal<(item?: any) => any>;
    /**
     * Property name from the data object to display
     */
    readonly name: _angular_core.InputSignal<keyof T>;
    /**
     * Data object containing the value to be displayed
     */
    readonly data: _angular_core.InputSignal<T>;
    /**
     * Whether to apply color styling to the label
     * @default true
     */
    readonly coloredLbl: _angular_core.InputSignal<boolean>;
    /**
     * Whether to apply color styling to the value
     */
    readonly coloredVal: _angular_core.InputSignal<boolean>;
    /**
     * Whether to center the content
     */
    readonly centered: _angular_core.InputSignal<boolean>;
    /**
     * Custom template for rendering the value
     */
    readonly customValueTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /**
     * Function to format the displayed value
     */
    readonly formatter: _angular_core.InputSignal<(item: any) => string | Promise<string> | Observable<string> | null | undefined>;
    /**
     * Tooltip text to display on hover
     */
    readonly hint: _angular_core.InputSignal<string>;
    /**
     * Label text to display
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * Whether to use light styling
     */
    readonly light: _angular_core.InputSignal<boolean>;
    /**
     * Whether to use compact styling
     */
    readonly mini: _angular_core.InputSignal<boolean>;
    /**
     * Route to navigate to when clicked
     */
    readonly route: _angular_core.InputSignal<string>;
    /**
     * Function that returns a route to navigate to when clicked
     */
    readonly routeFunc: _angular_core.InputSignal<(item: any) => Promise<string> | Observable<string> | null | undefined>;
    /**
     * Whether the value is editable
     */
    readonly editable: _angular_core.InputSignal<boolean>;
    /**
     * Whether to stack the label and value vertically
     * @default true
     */
    readonly stacked: _angular_core.InputSignal<boolean>;
    /**
     * The type of input/display to use
     */
    readonly type: _angular_core.InputSignal<InputType>;
    /**
     * The value to display (overrides data[name] if provided)
     */
    readonly value: _angular_core.InputSignal<any>;
    /**
     * Whether to wrap the label text
     * @default true
     */
    readonly wrapLabel: _angular_core.InputSignal<boolean>;
    /**
     * Whether the value is an email address
     */
    readonly isEmail: _angular_core.InputSignal<boolean>;
    /**
     * Whether the value is a phone number
     */
    readonly isPhone: _angular_core.InputSignal<boolean>;
    /**
     * Service for text case operations
     */
    readonly tS: TextCaseService;
    /**
     * Computes the route based on component inputs
     * Uses route input if provided, otherwise uses routeFunc
     * For email/phone values, creates a mailto: or tel: link
     */
    readonly computedRoute: _angular_core.Signal<Promise<string> | Observable<string>>;
    /**
     * Computes the value to display based on inputs
     * Uses value input if provided, otherwise uses data[name]
     */
    readonly computedValue: _angular_core.Signal<string | number | boolean>;
    /**
     * Applies formatting to the computed value using the formatter input
     * Returns a Promise or Observable with the formatted value
     */
    readonly computedValueFormatter: _angular_core.Signal<Promise<string | number | boolean> | Observable<string | number | boolean>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextCase2Component<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextCase2Component<any>, "text-case-2", never, { "action": { "alias": "action"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "coloredLbl": { "alias": "coloredLbl"; "required": false; "isSignal": true; }; "coloredVal": { "alias": "coloredVal"; "required": false; "isSignal": true; }; "centered": { "alias": "centered"; "required": false; "isSignal": true; }; "customValueTemplate": { "alias": "customValueTemplate"; "required": false; "isSignal": true; }; "formatter": { "alias": "formatter"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "light": { "alias": "light"; "required": false; "isSignal": true; }; "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "route": { "alias": "route"; "required": false; "isSignal": true; }; "routeFunc": { "alias": "routeFunc"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "wrapLabel": { "alias": "wrapLabel"; "required": false; "isSignal": true; }; "isEmail": { "alias": "isEmail"; "required": false; "isSignal": true; }; "isPhone": { "alias": "isPhone"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * A utility class that implements ITextCase2 interface for creating text case configurations for objects.
 * Provides a convenient way to define how object properties should be displayed.
 * @template T The type of data object being displayed
 */
declare class TextCase2ForObject<T = any> implements ITextCase2 {
    /** Property name from the data object to display */
    name: keyof T;
    /** Function to be called when the component is interacted with */
    action: any;
    /** Whether to apply color styling to the label */
    coloredLbl: boolean;
    /** Whether to apply color styling to the value */
    coloredVal: boolean;
    /** Form reference if used in a form context */
    form: any;
    /** Function to format the displayed value */
    formatter: ITextCase2<T>['formatter'];
    /** Tooltip text to display on hover */
    hint: string;
    /** Label text to display */
    label: string;
    /** Whether to use light styling */
    light: boolean;
    /** Whether to use compact styling */
    mini: boolean;
    /** Route to navigate to when clicked */
    route: string;
    /** Function that returns a route to navigate to when clicked */
    routeFunc: ITextCase2<T>['routeFunc'];
    /** Whether the value is editable */
    editable: boolean;
    /** Whether to stack the label and value vertically */
    stacked: boolean;
    /** The type of input/display to use */
    type: InputType;
    /** The value to display (overrides data[name] if provided) */
    value: any;
    /** Whether to wrap the label text */
    wrapLaInputType: boolean;
    /** Whether the value is an email address */
    isEmail: boolean;
    /** Whether the value is a phone number */
    isPhone: boolean;
    /**
     * Creates a new TextCase2ForObject instance
     * @param name The property name from the data object to display
     * @param label The label text to display
     * @param extra Optional additional configuration properties
     */
    constructor(name: keyof T, label: string, extra?: {
        formatter: (item: any) => string | Promise<string> | Observable<string>;
    });
}
/**
 * Interface defining the configuration options for TextCase2Component
 * @template T The type of data object being displayed
 */
interface ITextCase2<T = any> {
    /** Function to be called when the component is interacted with */
    action?: any;
    /** Whether to apply color styling to the label */
    coloredLbl?: boolean;
    /** Whether to apply color styling to the value */
    coloredVal?: boolean;
    /** Whether the value is editable */
    editable?: boolean;
    /** Function to format the displayed value */
    formatter?: (item: any) => string | Promise<string> | Observable<string> | null | undefined;
    /** Tooltip text to display on hover */
    hint?: string;
    /** Whether the value is an email address */
    isEmail?: boolean;
    /** Whether the value is a phone number */
    isPhone?: boolean;
    /** Label text to display */
    label?: string;
    /** Alternative field name (legacy support) */
    field?: string;
    /** Whether to use light styling */
    light?: boolean;
    /** Whether to use compact styling */
    mini?: boolean;
    /** Property name from the data object to display */
    name?: keyof T;
    /** Route to navigate to when clicked */
    route?: string;
    /** Function that returns a route to navigate to when clicked */
    routeFunc?: (item: any) => Promise<string> | Observable<string> | null | undefined;
    /** Whether to stack the label and value vertically */
    stacked?: boolean;
    /** The type of input/display to use */
    type?: InputType;
    /** The value to display (overrides data[name] if provided) */
    value?: any;
    /** Whether to wrap the label text */
    wrapLabel?: boolean;
}

/**
 * Label and value component emulating form label and form input component
 */
declare class TextCaseInputComponent extends TextCase2Component {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextCaseInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextCaseInputComponent, "text-case-input", never, {}, {}, never, never, true, never>;
}

declare class TextComponent {
    text: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextComponent, "app-text", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Interface representing a toggle option that extends the base IOption interface.
 *
 * @template TRow - The type of the data row associated with this option
 */
interface IToggleOption<TRow> extends Omit<IOption<TRow>, '_id'> {
    /**
     * Indicates whether the toggle is currently checked
     */
    checked?: boolean;
    /**
     * Indicates whether the toggle should be checked when first rendered
     */
    initiallyChecked?: boolean;
}
/**
 * Type representing a data row with an additional checked property.
 *
 * @template TRow - The base type of the data row
 */
type IToggleRow<TRow> = TRow & {
    /**
     * Indicates whether the row is checked/selected
     */
    checked?: boolean;
};

/**
 * A component that provides a toggle input form with search and grid layout capabilities.
 * Allows users to select multiple options from a list with toggle controls.
 *
 * @template TOption - The type of data objects in the list
 */
declare class ToggleInputFormComponent<TOption> {
    protected readonly uS: UtilityService<any>;
    /** Function to call when an item is added to the form */
    readonly addToFormFunc: _angular_core.InputSignal<(data?: TOption) => any>;
    /** Whether to toggle all items by default when the component initializes */
    readonly defaultToggleAll: _angular_core.InputSignal<boolean>;
    /** Whether the form is in read-only mode */
    readonly readOnly: _angular_core.InputSignal<boolean>;
    /** Whether to hide the search menu */
    readonly hideSearchMenu: _angular_core.InputSignal<boolean>;
    /** Whether to hide the grid layout menu */
    readonly hideGridMenu: _angular_core.InputSignal<boolean>;
    /** Whether to hide the toggle controls */
    readonly hideToggle: _angular_core.InputSignal<boolean>;
    /** Function to call when an item is removed from the form */
    readonly deleteFromFormFunc: _angular_core.InputSignal<(data?: TOption) => any>;
    /** The number of columns in the grid layout */
    readonly gridNo: _angular_core.ModelSignal<GridSize>;
    /** The field(s) in TOption to use as the label */
    readonly labelField: _angular_core.InputSignal<keyof TOption | (keyof TOption)[]>;
    /** The separator to use when concatenating multiple label fields */
    readonly labelSeparator: _angular_core.InputSignal<string>;
    /** The current search query */
    readonly searchQuery: _angular_core.ModelSignal<string>;
    /** Whether to show the "Toggle All" control */
    readonly showToggleAll: _angular_core.InputSignal<boolean>;
    /** The field in TOption to use as the value */
    readonly valueField: _angular_core.InputSignal<keyof { [P in keyof TOption as TOption[P] extends string | number ? P : never]: any; }>;
    /**
     * Determines whether an option is checked.
     * If you pass a field name: Checks if value exists in the specified field. If it is a boolean field, it checks if it is true.
     * If you pass a predicate function: Checks each object using the predicate function to evaluate if it is checked or not.
     */
    readonly checkedChecker: _angular_core.InputSignal<keyof TOption | ((option: TOption) => boolean)>;
    /** The list of options to display */
    readonly _list: _angular_core.InputSignal<TOption[]>;
    /** Emits the currently selected options when the selection changes */
    readonly selected: _angular_core.OutputEmitterRef<TOption[]>;
    /**
     * Computed property that returns the field name to check for checked status
     * @returns The field name or null if a predicate function is used
     */
    protected readonly checkedField: _angular_core.Signal<keyof TOption>;
    /**
     * Computed property that returns the predicate function to determine checked status
     * @returns The predicate function or null if a field name is used
     */
    protected readonly checkedPredicate: _angular_core.Signal<(option: TOption) => boolean>;
    /**
     * Transforms the input list into toggle options with initial checked state
     */
    protected readonly initialList: _angular_core.Signal<IToggleOption<TOption>[]>;
    /** Map of option values to their checked state */
    protected readonly selectedMap: _angular_core.WritableSignal<{
        [value: string]: boolean;
    }>;
    /**
     * The processed list of toggle options with current checked state
     */
    protected readonly list: _angular_core.Signal<IToggleOption<TOption>[]>;
    /** Tracks whether the default toggle all behavior has been handled */
    protected readonly hasHandledDefaultToggle: _angular_core.WritableSignal<boolean>;
    /** The current grid size */
    protected readonly _currentGrid: _angular_core.WritableSignal<number>;
    /** Computed property that returns the current grid size */
    readonly currentGrid: _angular_core.Signal<number>;
    /** Grid size for extra-large screens */
    protected readonly xxlGrid: _angular_core.Signal<number>;
    /** Grid size for large screens */
    protected readonly lgGrid: _angular_core.Signal<number>;
    /** Grid size for medium screens */
    protected readonly mdGrid: _angular_core.Signal<number>;
    /**
     * Effect that handles the default toggle all behavior
     */
    protected readonly defaultToggleAllEffect: _angular_core.EffectRef;
    /**
     * Available column layout options
     */
    protected readonly columnLengths: _angular_core.Signal<{
        label: string;
        value: GridSize;
    }[]>;
    /**
     * Toggles the checked state of an item
     * @param e - The toggle event
     * @param item - The item to toggle
     * @param emit - Whether to emit the selected event
     */
    protected toggleItem(e: {
        checked: boolean;
    }, item: IToggleOption<TOption>, emit?: boolean): void;
    /**
     * Checks an item
     * @param item - The item to check
     * @param emit - Whether to emit the selected event
     */
    protected checkItem(item: IToggleOption<TOption>, emit?: boolean): void;
    /**
     * Unchecks an item
     * @param item - The item to uncheck
     * @param emit - Whether to emit the selected event
     */
    protected uncheckItem(item: IToggleOption<TOption>, emit?: boolean): void;
    /**
     * Toggles all items
     * @param e - The toggle event
     */
    protected toggleAll(e: {
        checked: boolean;
    }): void;
    /**
     * Emits the currently selected items
     */
    protected emitSelected(): void;
    /**
     * Returns the current state of the list
     * @returns The current list with checked states
     */
    getState(): IToggleOption<TOption>[];
    /**
     * Resets the component to its initial state
     */
    reset(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleInputFormComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleInputFormComponent<any>, "toggle-input-form", never, { "addToFormFunc": { "alias": "addToFormFunc"; "required": false; "isSignal": true; }; "defaultToggleAll": { "alias": "defaultToggleAll"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "hideSearchMenu": { "alias": "hideSearchMenu"; "required": false; "isSignal": true; }; "hideGridMenu": { "alias": "hideGridMenu"; "required": false; "isSignal": true; }; "hideToggle": { "alias": "hideToggle"; "required": false; "isSignal": true; }; "deleteFromFormFunc": { "alias": "deleteFromFormFunc"; "required": false; "isSignal": true; }; "gridNo": { "alias": "gridNo"; "required": false; "isSignal": true; }; "labelField": { "alias": "labelField"; "required": false; "isSignal": true; }; "labelSeparator": { "alias": "labelSeparator"; "required": false; "isSignal": true; }; "searchQuery": { "alias": "searchQuery"; "required": false; "isSignal": true; }; "showToggleAll": { "alias": "showToggleAll"; "required": false; "isSignal": true; }; "valueField": { "alias": "valueField"; "required": true; "isSignal": true; }; "checkedChecker": { "alias": "checkedChecker"; "required": true; "isSignal": true; }; "_list": { "alias": "list"; "required": true; "isSignal": true; }; }, { "gridNo": "gridNoChange"; "searchQuery": "searchQueryChange"; "selected": "selected"; }, never, never, true, never>;
}
type GridSize = 6 | 4 | 3 | 2 | 1;

declare class TranslatorCaseComponent {
    text: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslatorCaseComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TranslatorCaseComponent, "translator-case", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Component for displaying view and form buttons.
 * Provides a standardized way to show action buttons in views and forms.
 */
declare class ViewFormButtonsComponent {
    /**
     * Controls the visibility of the buttons.
     * When true, the buttons will be displayed; when false, they will be hidden.
     */
    isShow: _angular_core.InputSignal<boolean>;
    /**
     * Custom CSS class to apply to the component.
     * Allows for customization of the component's appearance.
     */
    class: _angular_core.InputSignal<string>;
    /**
     * Initializes a new instance of the ViewFormButtonsComponent.
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ViewFormButtonsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ViewFormButtonsComponent, "view-form-buttons", never, { "isShow": { "alias": "isShow"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IInputTableScheme extends IFormSchema {
    __ID?: number;
    templateValue?: any;
}
interface IValidationResp<T> {
    rowID: string;
    rowIndex?: number;
    errors?: string[];
    data?: T;
}
interface IUploadSubmissionResp {
    fileName?: string;
    filePath: string;
    totalProcessed?: number;
    totalSuccess?: number;
    totalFail?: number;
    percentageCompletion?: number;
    report?: {
        fileName: string;
        filePath: string;
    };
}

declare class InputTableComponent implements OnInit {
    uS: UtilityService;
    private cdr;
    bordered: boolean;
    ioFormatted: boolean;
    keyField: 'field' | 'label';
    label: string;
    pageSizeOptions: number[];
    realTimeValidation: boolean;
    showAddRow: boolean;
    showCSV: boolean;
    showEditRow: boolean;
    showExportBtn: boolean;
    showIOBtns: boolean;
    showSN: boolean;
    submitted: EventEmitter<any>;
    submitFunc: (arrValues: any[]) => Promise<any>;
    validationFunc: (arrVal: any[]) => Promise<IValidationResp<any>[]>;
    data: any[];
    form: FormArray<FormGroup<any>>;
    cellOptions: IFormOptions;
    cellCountryCode3s: IFormOptions;
    loading: boolean;
    numOfRowsCtrl: FormControl;
    schemas: IInputTableScheme[];
    templateObj: {};
    private hasAddedValidators;
    loadingErrorList: boolean;
    errors: IValidationResp<any>[];
    aErrors: IValidationResp<any>[];
    set _numOfRows(v: number);
    set _schemas(value: IInputTableScheme[]);
    set _data(value: any[]);
    schemaMap: {
        [x: string]: IInputTableScheme;
    };
    errorListTag: ModalComponent;
    constructor(uS: UtilityService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    addCellOption: (scheme: IFormSchema, form: FormGroup, cellVal: any, index: number) => Promise<void>;
    initiateForm(_schemas?: IInputTableScheme[]): void;
    sortData(sort: Sort$1): void;
    submit(): Promise<void>;
    disableRows(index?: number): void;
    enableRows(): void;
    subFormTrackBy: (index: number, item: any) => any;
    schemeTrackBy: (index: number, item: IInputTableScheme) => number;
    editRow(index: number): void;
    removeRow(index: number): void;
    createRowForm: (data?: any, _schemas?: IInputTableScheme[]) => FormGroup<{
        [x: string]: AbstractControl<any, any, any>;
    }>;
    get formIsPending(): boolean;
    logForm(): void;
    jumpTo(rowid: string): void;
    showErrors(): void;
    validate(): void;
    validateAsync(): Promise<void>;
    addRow: (index?: number, form?: FormGroup<{
        [x: string]: AbstractControl<any, any, any>;
    }>) => any;
    openPage(e: PageEvent): void;
    downloadCSV(rows?: any[], label?: string): void;
    downloadTemplate(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTableComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputTableComponent, "app-input-table", never, { "bordered": { "alias": "bordered"; "required": false; }; "ioFormatted": { "alias": "ioFormatted"; "required": false; }; "keyField": { "alias": "keyField"; "required": false; }; "label": { "alias": "label"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "realTimeValidation": { "alias": "realTimeValidation"; "required": false; }; "showAddRow": { "alias": "showAddRow"; "required": false; }; "showCSV": { "alias": "showCSV"; "required": false; }; "showEditRow": { "alias": "showEditRow"; "required": false; }; "showExportBtn": { "alias": "showExportBtn"; "required": false; }; "showIOBtns": { "alias": "showIOBtns"; "required": false; }; "showSN": { "alias": "showSN"; "required": false; }; "submitFunc": { "alias": "submitFunc"; "required": false; }; "validationFunc": { "alias": "validationFunc"; "required": false; }; "_numOfRows": { "alias": "numOfRows"; "required": false; }; "_schemas": { "alias": "schemas"; "required": false; }; "_data": { "alias": "data"; "required": false; }; }, { "submitted": "submitted"; }, never, never, true, never>;
}

declare class InputTableService {
    constructor();
    formatDataForSubmission: (arrVal: any[], formGroup: FormGroup) => {}[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTableService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InputTableService>;
}

/**
 * Component that displays an idle timeout dialog to the user.
 * Shows remaining time before session expiration and allows user interaction.
 */
declare class IdlerComponent {
    dialogRef: MatDialogRef<IdlerComponent>;
    uS: UtilityService;
    data: {
        timeLeft: Signal<number>;
    };
    /**
     * Computed property that formats the remaining time into hours, minutes, and seconds.
     * Uses the utility service to convert seconds to a formatted object.
     */
    protected readonly timeLeftFormatted: Signal<{
        hours: number;
        mins: number;
        secs: number;
    }>;
    /**
     * Computed property that creates a human-readable string of the remaining time.
     * @returns A formatted string representation of the time remaining (e.g. "2hrs 30min 15s")
     */
    protected readonly timeLeftString: Signal<string>;
    /**
     * Creates an instance of IdlerComponent.
     * @param dialogRef - Reference to the dialog opened by the Material Dialog service
     * @param uS - Utility service for time formatting and other helper functions
     */
    constructor(dialogRef: MatDialogRef<IdlerComponent>, uS: UtilityService, data: {
        timeLeft: Signal<number>;
    });
    /**
     * Closes the idle timeout dialog.
     * This typically indicates user activity and resets the idle timer.
     */
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdlerComponent, [null, null, { optional: true; }]>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdlerComponent, "app-idler", never, {}, {}, never, never, true, never>;
}

/**
 * Service that manages user idle state detection and timeout warnings.
 *
 * This service monitors user activity and triggers idle state transitions,
 * displays warning dialogs, and executes registered callbacks when a user
 * times out due to inactivity.
 */
declare class IdlerService {
    protected idle: Idle;
    dialog: MatDialog;
    /** Current idle state message */
    protected readonly idleState: _angular_core.WritableSignal<string>;
    /** Collection of functions to execute when idle timeout occurs */
    protected onIdleFunctions: (() => any)[];
    /** Remaining time before timeout occurs (in seconds) */
    protected readonly _timeLeft: _angular_core.WritableSignal<number>;
    /** Reference to the idle warning modal dialog */
    idlerModal: MatDialogRef<IdlerComponent>;
    /** Computed signal exposing the remaining time before timeout */
    readonly timeLeft: _angular_core.Signal<number>;
    /** Subject controlling whether idle monitoring is active */
    protected readonly allowedToWatch$: ReplaySubject<boolean>;
    /** Subject for setting the timeout duration in seconds */
    readonly timeoutSeconds$: Subject<number>;
    /**
     * Creates an instance of IdlerService.
     *
     * @param idle - The Angular Idle service for detecting user inactivity
     * @param dialog - Material Dialog service for displaying timeout warnings
     */
    constructor(idle: Idle, dialog: MatDialog);
    /**
     * Activates idle monitoring by setting allowedToWatch to true.
     * This enables the service to begin tracking user activity.
     */
    dispatchStart(): void;
    /**
     * Deactivates idle monitoring by setting allowedToWatch to false.
     * This stops the service from tracking user activity.
     */
    dispatchStop(): void;
    /**
     * Registers a function to be called when the user times out due to inactivity.
     *
     * @param func - The function to execute on idle timeout
     */
    addOnIdleFunction(func: () => any): void;
    /**
     * Starts the idle detection with the specified timeout values.
     *
     * @param idleTimeSeconds - The number of seconds before user is considered idle
     * @param timeoutSeconds - The number of seconds after becoming idle before timing out
     *                         (defaults to 20% of idle time if not specified)
     */
    protected start(idleTimeSeconds: number, timeoutSeconds?: number): void;
    /**
     * Clears all registered idle timeout functions.
     */
    protected clear(): void;
    /**
     * Opens the timeout warning modal dialog.
     */
    protected openTimeWarningModal(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdlerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IdlerService>;
}

/**
 * Directive that formats numbers with commas in input fields.
 *
 * This directive implements ControlValueAccessor to integrate with Angular forms.
 * It automatically formats numeric input values with commas as thousands separators
 * while maintaining the actual numeric value in the form model.
 *
 * @example
 * ```html
 * <input appCommafyNumber [value]="1000">
 * <!-- Will display as "1,000" but the model value will be "1000" -->
 * ```
 */
declare class CommafyNumberDirective implements ControlValueAccessor {
    private elementRef;
    private numberPipe;
    /**
     * Internal storage for the unformatted value
     * @private
     */
    private _value;
    /**
     * Whether the input is disabled
     */
    disableInput: any;
    /**
     * Creates an instance of CommafyNumberDirective.
     *
     * @param elementRef - Reference to the host input element
     * @param numberPipe - Angular's DecimalPipe for number formatting
     */
    constructor(elementRef: ElementRef<HTMLInputElement>, numberPipe: DecimalPipe);
    /**
     * Updates the disabled state when the input changes
     */
    ngOnChanges(): void;
    /**
     * Sets the input value and formats it with commas
     *
     * @param value - The numeric value to set and format
     */
    set value(value: number);
    /**
     * Formats a value by adding commas using DecimalPipe
     *
     * @param value - The value to format
     * @returns The formatted value with commas
     * @private
     */
    private formatValue;
    /**
     * Removes formatting (commas) from a value
     *
     * @param value - The formatted value
     * @returns The raw numeric value without commas
     * @private
     */
    private unFormatValue;
    /**
     * Handles input events, unformats the value for the model,
     * and reformats the display value with commas
     *
     * @param value - The current input value
     */
    onInput(value: any): void;
    /**
     * Handles focus events
     */
    onFocus(): void;
    /**
     * Writes a value to the input element with proper formatting
     * Implements ControlValueAccessor
     *
     * @param value - The value to write
     */
    writeValue(value: string): void;
    /**
     * Registers a callback function for value changes
     * Implements ControlValueAccessor
     *
     * @param fn - The callback function
     */
    registerOnChange(fn: any): void;
    /**
     * Registers a callback function for touched state
     * Implements ControlValueAccessor
     *
     * @param fn - The callback function
     */
    registerOnTouched(fn: any): void;
    /**
     * Internal method that is set by registerOnChange to propagate changes back to the form
     *
     * @param value - The new value
     * @private
     */
    _onChange(value: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommafyNumberDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CommafyNumberDirective, "[appCommafyNumber]", never, { "disableInput": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * Directive that enables drag and drop file upload functionality.
 * Applies visual feedback during drag operations and emits selected files.
 */
declare class DragDropFileUploadDirective {
    uS: UtilityService;
    /**
     * Controls whether multiple files can be dropped at once.
     * If false, only single file drops are allowed.
     */
    multiple: boolean;
    /**
     * Event emitted when files are successfully dropped.
     * Emits an array of File objects.
     */
    fileDropped: EventEmitter<File[]>;
    /**
     * Background color binding that changes during drag interactions.
     */
    private background;
    /**
     * Handles the dragover event.
     * Changes background color to provide visual feedback.
     * @param event - The dragover event
     */
    dragOver(event: any): void;
    /**
     * Handles the dragleave event.
     * Resets background color when drag leaves the element.
     * @param event - The dragleave event
     */
    dragLeave(event: any): void;
    /**
     * Handles the drop event.
     * Processes dropped files and emits them if valid.
     * Validates against multiple files if multiple is false.
     * @param event - The drop event containing the files
     */
    drop(event: any): void;
    /**
     * Creates an instance of DragDropFileUploadDirective.
     * @param uS - Utility service for displaying notifications
     */
    constructor(uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragDropFileUploadDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DragDropFileUploadDirective, "[libDragDropFileUpload]", never, { "multiple": { "alias": "multiple"; "required": false; }; }, { "fileDropped": "fileDropped"; }, never, never, true, never>;
}

/**
 * Directive that automatically formats input values based on their type.
 * Supports formatting for text (title case), numbers (with commas), and percentages.
 * Can be disabled with the noformat attribute or through the InputFormatService.
 */
declare class InputFormatDirective implements ControlValueAccessor {
    private elementRef;
    private decimalPipe;
    private el;
    /** The original input type (text, number, percentage) */
    oType: InputType;
    /**
     * Whether formatting should be disabled for this input
     * @returns True if formatting is disabled via attribute or service
     */
    get noFormatting(): boolean;
    /**
     * Whether text formatting should be disabled for this input
     * @returns True if text formatting is disabled via attribute or service
     */
    get noTextFormat(): boolean;
    /**
     * Whether debug mode is enabled for this input
     * @returns True if debug is enabled via attribute
     */
    get isDebug(): boolean;
    /**
     * Whether this input type should be formatted
     * @returns True if the input type is in the accepted types list
     */
    get shouldFormat(): boolean;
    /** List of input types that can be formatted */
    readonly acceptedType: InputType[];
    /** Service for page-level formatting configuration */
    private readonly inputFormatService;
    constructor(elementRef: ElementRef<HTMLInputElement>, decimalPipe: DecimalPipe);
    /**
     * Initialize the directive, determine input type and apply initial formatting
     */
    ngOnInit(): void;
    /**
     * Add appropriate icons after view initialization based on input type
     */
    ngAfterViewInit(): void;
    private __value;
    /**
     * Set the internal value
     */
    set _value(v: string | number | boolean | null);
    /**
     * Get the current value
     */
    get value(): string | number | boolean | null;
    /**
     * Set the input value with appropriate formatting
     * @param value The value to set
     */
    set value(value: string | number | boolean | null);
    /**
     * Handle input events and format values accordingly
     * @param value The input value
     */
    input(value: any): void;
    /**
     * Apply formatting when the input loses focus
     */
    _onBlur(): void;
    /**
     * Remove formatting when the input gains focus
     */
    onFocus(): void;
    /**
     * Callback for value changes
     * @param value The new value
     */
    _onChange(value: any): void;
    /**
     * Write a new value to the input with appropriate formatting
     * Implements ControlValueAccessor
     * @param value The value to write
     */
    writeValue(value: any): void;
    /**
     * Register a callback function for value changes
     * Implements ControlValueAccessor
     * @param fn The callback function
     */
    registerOnChange(fn: (value: any) => void): void;
    /**
     * Register a callback function for touched state
     * Implements ControlValueAccessor
     */
    registerOnTouched(): void;
    /**
     * Check if the last character of a value is a decimal separator
     * @param value The value to check
     * @returns True if the last character is a decimal point
     */
    isLastCharacterDecimalSeparator(value: string | number): boolean;
    /**
     * Format a number by adding commas
     * @param value The number value to format
     */
    private setNumberInput;
    /**
     * Format a percentage by adding % sign
     * @param value The percentage value to format
     */
    private setPercentageInput;
    /**
     * Format text by converting to title case
     * @param value The text to format
     */
    private setTextInput;
    /**
     * Set a value on the input element without special formatting
     * @param value The value to set
     */
    private setInput;
    /**
     * Set a value on a checkbox input
     * @param value The boolean value to set
     */
    private setCheckboxInput;
    /**
     * Remove comma formatting from numbers when focused
     */
    private unFormatNumber;
    /**
     * Remove percentage formatting when focused
     */
    private unFormatPercentage;
    /**
     * Set the disabled state of the input
     * Implements ControlValueAccessor
     * @param val Whether the input should be disabled
     */
    setDisabledState(val: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputFormatDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputFormatDirective, "input:not([matInput]):not([noformat])", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}
declare class InputFormatService {
    /** Don't use the input formattter on this page */
    pageNoformat: boolean;
    /** Don't use the input formattter for text inputs on this page */
    pageNoTextFormat: boolean;
    readonly locale: _angular_core.Signal<"en-US" | "fr-FR">;
    readonly nfS: NumberFormatService;
    /**
     * Convert input value to number
     * @param value Input value
     * @returns The numeric value with spaces removed according to locale
     */
    normalise(value: string): number;
    normaliseForInput(value: string): string;
    toTitleCase(str: string | number): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputFormatService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InputFormatService>;
}

/**
 * Directive that ensures input values are always negative numbers.
 *
 * This directive automatically prepends a minus sign to any input value
 * if it doesn't already start with one.
 *
 * @example
 * ```html
 * <input type="number" appNegativeNumberOnly>
 * ```
 */
declare class NegativeNumberOnlyDirective {
    private el;
    /**
     * Creates an instance of NegativeNumberOnlyDirective.
     *
     * @param el - Reference to the host input element
     */
    constructor(el: ElementRef<HTMLInputElement>);
    /**
     * Handles input changes to ensure values are always negative.
     *
     * @param value - The current value of the input element
     */
    onChange(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NegativeNumberOnlyDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NegativeNumberOnlyDirective, "[appNegativeNumberOnly]", never, {}, {}, never, never, true, never>;
}

/**
 * Directive that translates the content of an element using the TranslationService.
 * Apply this directive to elements that need their text content translated.
 *
 * @example
 * <div appTranslator>Text to translate</div>
 * <div [appTranslator]="'key.to.translate'">Fallback text</div>
 */
declare class TranslatorDirective {
    private element;
    private renderer;
    private tS;
    /**
     * Input for the translation key. If not provided, the element's inner text will be used.
     */
    readonly appTranslator: _angular_core.InputSignal<string>;
    /**
     * When true, enables debug mode which logs translation details and adds a debugger breakpoint.
     */
    readonly debug: _angular_core.InputSignal<boolean>;
    /**
     * Configuration options for the translator.
     * @default { miniLoader: true }
     */
    readonly translateOptions: _angular_core.InputSignal<ITranslatorConfig>;
    /**
     * Creates an instance of TranslatorDirective.
     *
     * @param element - Reference to the host element
     * @param renderer - Angular's renderer for DOM manipulation
     * @param tS - The translation service used to translate content
     */
    constructor(element: ElementRef<HTMLElement>, renderer: Renderer2, tS: TranslationService);
    /**
     * Lifecycle hook that is called after the directive's content has been initialized.
     * Handles the translation of the element's content.
     */
    ngAfterContentInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslatorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TranslatorDirective, "[appTranslator]", never, { "appTranslator": { "alias": "appTranslator"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "translateOptions": { "alias": "translateOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Directive that adds a CSS class to an element when the associated form or form controls are invalid.
 *
 * @example
 * ```html
 * <div [formInvalidClass]="myForm" [includedNames]="['firstName', 'email']">
 *   <!-- Form content -->
 * </div>
 * ```
 */
declare class FormInvalidClassDirective<TForm extends {
    [K in keyof TForm]: AbstractControl<any, any>;
}> implements AfterViewInit {
    el: ElementRef<HTMLElement>;
    /**
     * The form group to monitor for validation status changes.
     */
    formInvalidClass: FormGroup<TForm>;
    /**
     * Optional array of form control names to monitor.
     * If provided, only these specific controls will be monitored.
     * If not provided, the entire form group will be monitored.
     */
    includedNames: (keyof TForm)[];
    /**
     * Subscription to form status changes.
     * @internal
     */
    sub: Subscription;
    /**
     * @param el Reference to the host element where the CSS class will be added/removed
     */
    constructor(el: ElementRef<HTMLElement>);
    /**
     * Initializes the directive by setting up subscriptions to form control status changes.
     * Adds 'custom-form-invalid' class to the host element when monitored controls are invalid.
     */
    ngAfterViewInit(): void;
    /**
     * Cleans up subscriptions when the directive is destroyed.
     */
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormInvalidClassDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormInvalidClassDirective<any>, "[formInvalidClass]", never, { "formInvalidClass": { "alias": "formInvalidClass"; "required": false; }; "includedNames": { "alias": "includedNames"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Directive that handles responsive behavior based on viewport size.
 * Allows applying different classes and visibility settings for mobile and desktop views.
 *
 * @example
 * <div mresponsiveness mobileClass="mobile-styling" desktopClass="desktop-styling"></div>
 * <div mresponsiveness hideMobile="true"></div>
 */
declare class ResponsivenessDirective implements OnDestroy {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** CSS classes to apply when viewport is mobile */
    mobileClass?: string;
    /** CSS classes to apply when viewport is desktop */
    desktopClass?: string;
    /** Whether to hide the element on mobile devices */
    hideMobile?: boolean;
    /** Whether to hide the element on desktop devices */
    hideDesktop?: boolean;
    /** Subscription to viewport changes */
    sub: Subscription;
    constructor(elRef: ElementRef<HTMLDivElement>, uS: UtilityService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * If viewport is mobile
     */
    handleMobile(): void;
    /**
     * If viewport is desktop
     */
    handleDesktop(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponsivenessDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ResponsivenessDirective, "[mresponsiveness]", never, { "mobileClass": { "alias": "mobileClass"; "required": false; }; "desktopClass": { "alias": "desktopClass"; "required": false; }; "hideMobile": { "alias": "hideMobile"; "required": false; }; "hideDesktop": { "alias": "hideDesktop"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that applies specified CSS classes only on mobile viewports.
 * Classes are added when on mobile and removed when on desktop.
 *
 * @example
 * <div mobileClass="mobile-only-styling another-class"></div>
 */
declare class MobileClassDirective implements OnDestroy {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** CSS classes to apply when viewport is mobile */
    mobileClass?: string;
    /** Subscription to viewport changes */
    sub: Subscription;
    constructor(elRef: ElementRef<HTMLDivElement>, uS: UtilityService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * If viewport is mobile
     */
    handleMobile(): void;
    /**
     * If viewport is desktop
     */
    handleDesktop(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobileClassDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MobileClassDirective, "[mobileClass]", never, { "mobileClass": { "alias": "mobileClass"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that applies specified CSS classes only on desktop viewports.
 * Classes are added when on desktop and removed when on mobile.
 *
 * @example
 * <div desktopClass="desktop-only-styling another-class"></div>
 */
declare class DesktopClassDirective implements OnDestroy {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** CSS classes to apply when viewport is desktop */
    desktopClass?: string;
    /** Subscription to viewport changes */
    sub: Subscription;
    constructor(elRef: ElementRef<HTMLDivElement>, uS: UtilityService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * If viewport is mobile
     */
    handleMobile(): void;
    /**
     * If viewport is desktop
     */
    handleDesktop(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DesktopClassDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DesktopClassDirective, "[desktopClass]", never, { "desktopClass": { "alias": "desktopClass"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that hides elements on mobile viewports.
 * Element is hidden when on mobile and shown when on desktop.
 *
 * @example
 * <div hideMobile></div>
 */
declare class HideMobileDirective implements OnDestroy {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** Subscription to viewport changes */
    sub: Subscription;
    constructor(elRef: ElementRef<HTMLDivElement>, uS: UtilityService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * If viewport is mobile
     */
    handleMobile(): void;
    /**
     * If viewport is desktop
     */
    handleDesktop(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HideMobileDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HideMobileDirective, "[hideMobile]", never, {}, {}, never, never, true, never>;
}
/**
 * Directive that hides elements on desktop viewports.
 * Element is hidden when on desktop and shown when on mobile.
 *
 * @example
 * <div hideDesktop></div>
 */
declare class HideDesktopDirective implements OnDestroy {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** Subscription to viewport changes */
    sub: Subscription;
    constructor(elRef: ElementRef<HTMLDivElement>, uS: UtilityService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * If viewport is mobile
     */
    handleMobile(): void;
    /**
     * If viewport is desktop
     */
    handleDesktop(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HideDesktopDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HideDesktopDirective, "[hideDesktop]", never, {}, {}, never, never, true, never>;
}
/**
 * Module that bundles all responsiveness directives for easy import.
 * Import this module to use any of the responsiveness directives.
 */
declare class ETSResponsivenessDirectiveModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSResponsivenessDirectiveModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ETSResponsivenessDirectiveModule, never, [typeof i1$1.CommonModule, typeof ResponsivenessDirective, typeof MobileClassDirective, typeof DesktopClassDirective, typeof HideMobileDirective, typeof HideDesktopDirective], [typeof ResponsivenessDirective, typeof MobileClassDirective, typeof DesktopClassDirective, typeof HideMobileDirective, typeof HideDesktopDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ETSResponsivenessDirectiveModule>;
}

/**
 * Directive that enables image upload functionality on an element.
 * Clicking the element opens a file dialog for selecting an image.
 *
 * @example
 * ```html
 * <div imageUpload (extractedImg)="handleImage($event)" [disableUpload]="isDisabled"></div>
 * ```
 */
declare class ImageUpload implements AfterViewInit {
    el: ElementRef<HTMLImageElement>;
    uS: UtilityService;
    /**
     * Emits the selected image file when an image is successfully uploaded.
     * The emitted value is a File object representing the selected image.
     */
    extractedImg: EventEmitter<File>;
    /**
     * Handles click events on the element to open the file dialog.
     * If disableUpload is true, this handler will not trigger the file dialog.
     */
    onClick(): void;
    /**
     * When true, prevents the file dialog from opening on click.
     * Useful for temporarily disabling upload functionality without removing the directive.
     */
    disableUpload: boolean;
    /**
     * Reference to the hidden file input element.
     * This element is created programmatically and triggered via JavaScript.
     */
    fileEl: HTMLInputElement;
    /**
     * Creates an instance of ImageUpload directive.
     *
     * @param el - Reference to the host element
     * @param uS - Utility service for notifications and other utilities
     */
    constructor(el: ElementRef<HTMLImageElement>, uS: UtilityService);
    /**
     * Sets up the element after view initialization.
     * Configures cursor style and file change handler.
     * The cursor is set to 'pointer' to indicate clickability.
     */
    ngAfterViewInit(): void;
    /**
     * Programmatically triggers a click on the hidden file input element.
     * This opens the browser's file selection dialog.
     */
    openFile(): void;
    /**
     * Processes the selected files and validates them.
     * Emits the file if it passes validation checks for size and type.
     *
     * @param files - The list of files selected by the user
     * @returns void - Returns early if validation fails
     */
    preview(files: FileList): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageUpload, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ImageUpload, "[imageUpload]", never, { "disableUpload": { "alias": "disableUpload"; "required": false; }; }, { "extractedImg": "extractedImg"; }, never, never, true, never>;
}
/**
 * Directive that handles image loading with fallback support.
 * Loads images with proper error handling and type-based fallbacks.
 * Provides a placeholder while the main image is loading.
 *
 * @example
 * ```html
 * <img [imageLoader]="imageUrl" [imageType]="ImageType.Profile">
 * ```
 */
declare class ImageLoaderDirective {
    el: ElementRef<HTMLImageElement>;
    /**
     * Source URL of the image.
     * This is set internally when the imageLoader input changes.
     */
    src: string;
    /**
     * Sets the image source and triggers image loading.
     * When this value changes, the image loading process is initiated.
     *
     * @param v - The URL of the image to load
     */
    set imageLoader(v: string);
    /**
     * Type of image to load, used for fallback selection.
     * This determines which placeholder and fallback images to use.
     * Should be a value from the ImageType enum.
     */
    imageType: ImageType;
    /**
     * Creates an instance of ImageLoaderDirective.
     *
     * @param el - Reference to the host image element
     */
    constructor(el: ElementRef<HTMLImageElement>);
    /**
     * Loads an image with fallback support.
     * First sets a minimal placeholder, then attempts to load the full image.
     * If the image fails to load, the placeholder remains visible.
     *
     * @param src - The source URL of the image to load (defaults to this.src)
     * @param type - The type of image, used for fallback selection (defaults to this.imageType)
     */
    loadImage(src?: string, type?: ImageType): void;
    /**
     * Retrieves image configuration based on the specified type.
     * Falls back to a default image if the type is not found.
     *
     * @param type - The type of image to retrieve
     * @returns The image configuration for the specified type, containing src and min properties
     */
    getImageByType(type: ImageType): {
        src: string;
        min: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageLoaderDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ImageLoaderDirective, "[imageLoader]", never, { "imageLoader": { "alias": "imageLoader"; "required": false; }; "imageType": { "alias": "imageType"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that captures click events on buttons.
 * Logs information about the clicked button and its location.
 * Can be used for analytics or tracking user interactions.
 *
 * @example
 * This directive is automatically applied to all button elements.
 */
declare class OnClickDirective {
    private el;
    /**
     * Handles click events on buttons.
     * Captures and logs information about the button and its location.
     * This can be extended to send analytics data to a server.
     *
     * @param $event - The mouse event triggered by the click
     */
    onClick($event: MouseEvent): void;
    /**
     * Creates an instance of OnClickDirective.
     *
     * @param el - Reference to the host button element
     */
    constructor(el: ElementRef);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OnClickDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OnClickDirective, "button", never, {}, {}, never, never, false, never>;
}
/**
 * Custom router link directive that extends functionality beyond Angular's routerLink.
 * Supports relative navigation, email links, phone links, and query parameters.
 * Provides more flexibility than the standard routerLink directive.
 *
 * @example
 * ```html
 * <!-- Standard route navigation -->
 * <a [mrouterLink]="'products/detail'" [mqueryParams]="{id: 123}">Product</a>
 *
 * <!-- Email link -->
 * <a [mrouterLink]="'support@example.com'" [isEmail]="true">Email Support</a>
 *
 * <!-- Phone link -->
 * <a [mrouterLink]="'555-123-4567'" [isPhone]="true">Call Us</a>
 * ```
 */
declare class MrouterLinkirective implements AfterViewInit {
    el: ElementRef<HTMLAnchorElement>;
    route: ActivatedRoute;
    router: Router;
    uS: UtilityService;
    /**
     * The route to navigate to.
     * Can be a relative path, absolute path, email address, or phone number.
     */
    mrouterLink: string;
    /**
     * Sets the route and updates the element's href.
     * Triggers the setRouter method to configure the link behavior.
     *
     * @param v - The route, email, or phone number to link to
     */
    set _mrouterLink(v: string);
    /**
     * The activated route to use as a base for relative navigation.
     * If not provided, the current route will be used.
     */
    mrouterLinkActivatedRoute: ActivatedRoute;
    /**
     * Query parameters to include in the navigation.
     * These will be appended to the URL as query string parameters.
     */
    mqueryParams: any;
    /**
     * When true, treats the link as a phone number.
     * The link will use the 'tel:' protocol instead of navigation.
     */
    isPhone: boolean;
    /**
     * When true, treats the link as an email address.
     * The link will use the 'mailto:' protocol instead of navigation.
     */
    isEmail: boolean;
    /**
     * Creates an instance of MrouterLinkirective.
     *
     * @param el - Reference to the host anchor element
     * @param route - The current activated route for relative navigation
     * @param router - The Angular router service for navigation
     * @param uS - Utility service for environment and other utilities
     */
    constructor(el: ElementRef<HTMLAnchorElement>, route: ActivatedRoute, router: Router, uS: UtilityService);
    /**
     * Initializes the router link after the view is initialized.
     * Calls setRouter to configure the link behavior.
     */
    ngAfterViewInit(): void;
    /**
     * Configures the element's href and click behavior based on the link type.
     * Handles email, phone, and route navigation differently.
     * For route navigation, it parses query parameters and handles relative paths.
     */
    setRouter(): void;
    /**
     * Converts a query parameter object to a URL query string.
     * Formats the parameters as key=value pairs joined by ampersands.
     *
     * @param q - The query parameter object
     * @returns A formatted query string (without the leading '?')
     */
    stringifyQueryParams(q: {
        [x: string]: string;
    }): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MrouterLinkirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MrouterLinkirective, "[mrouterLink]", never, { "_mrouterLink": { "alias": "mrouterLink"; "required": false; }; "mrouterLinkActivatedRoute": { "alias": "mrouterLinkActivatedRoute"; "required": false; }; "mqueryParams": { "alias": "mqueryParams"; "required": false; }; "isPhone": { "alias": "isPhone"; "required": false; }; "isEmail": { "alias": "isEmail"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that adds PerfectScrollbar functionality to an element.
 * Provides customizable scrolling behavior with various options.
 * Only initializes on non-mobile devices to avoid conflicts with native scrolling.
 *
 * @example
 * ```html
 * <div PSBox [PSBoxNoHorizontal]="true">
 *   <!-- Content that needs custom scrollbars -->
 * </div>
 * ```
 */
declare class PSDirective implements OnChanges, AfterViewInit {
    el: ElementRef;
    uS: UtilityService;
    /**
     * Element or selector to apply PerfectScrollbar to (defaults to host element).
     * Can be a CSS selector string or an HTMLElement reference.
     */
    selector: string | HTMLElement;
    /**
     * When true, disables horizontal scrolling.
     * Useful for content that should only scroll vertically.
     */
    noHorizontal: boolean;
    /**
     * When true, disables vertical scrolling.
     * Useful for content that should only scroll horizontally.
     */
    noVertical: boolean;
    /**
     * Reference to the PerfectScrollbar instance.
     * Used to call methods on the scrollbar instance, such as update().
     */
    protected psInstance: PerfectScrollbar;
    /**
     * Creates an instance of PSDirective.
     *
     * @param el - Reference to the host element
     * @param uS - Utility service for device detection and other utilities
     */
    constructor(el: ElementRef, uS: UtilityService);
    /**
     * Responds to changes in the directive's inputs.
     * Currently empty, but can be extended to reinitialize the scrollbar when inputs change.
     */
    ngOnChanges(): void;
    /**
     * Initializes the PerfectScrollbar after the view is initialized.
     * Calls the init method to create the PerfectScrollbar instance.
     */
    ngAfterViewInit(): void;
    /**
     * Initializes the PerfectScrollbar instance with configured options.
     * Only initializes on non-mobile devices to avoid conflicts with native scrolling.
     * Uses setTimeout to ensure the DOM is fully rendered before initialization.
     */
    init(): void;
    /**
     * Updates the PerfectScrollbar instance.
     * Should be called when content changes to refresh the scrollbars.
     * Safe to call even if the instance doesn't exist (e.g., on mobile).
     */
    update(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PSDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PSDirective, "[PSBox]", never, { "selector": { "alias": "PSBox"; "required": false; }; "noHorizontal": { "alias": "PSBoxNoHorizontal"; "required": false; }; "noVertical": { "alias": "PSBoxNoVertical"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that equalizes the width of child elements.
 * Finds the maximum width among children and can apply it to all.
 * Useful for creating consistent column widths in tables or grids.
 *
 * @example
 * ```html
 * <div equalChildren>
 *   <div>Column 1</div>
 *   <div>Column 2 with longer content</div>
 *   <div>Column 3</div>
 * </div>
 * ```
 */
declare class EqualChildrenDirective implements OnChanges, AfterViewInit {
    el: ElementRef;
    uS: UtilityService;
    /**
     * Creates an instance of EqualChildrenDirective.
     *
     * @param el - Reference to the host element containing the children to equalize
     * @param uS - Utility service for various utilities
     */
    constructor(el: ElementRef, uS: UtilityService);
    /**
     * Responds to changes in the directive's inputs.
     * Currently empty, but can be extended to recalculate widths when inputs change.
     */
    ngOnChanges(): void;
    /**
     * Calculates the maximum width of child elements after view initialization.
     * Note: Currently only calculates but doesn't apply the width.
     * This method could be extended to apply the maximum width to all children.
     */
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EqualChildrenDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EqualChildrenDirective, "[equalChildren]", never, {}, {}, never, never, true, never>;
}
/**
 * Angular module that exports all directives for use in other modules.
 * Import this module to make all directives available in your components.
 *
 * @example
 * ```typescript
 * @NgModule({
 *   imports: [DirectivesModule]
 * })
 * export class MyModule { }
 * ```
 */
declare class DirectivesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DirectivesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DirectivesModule, never, [typeof i1$1.CommonModule, typeof InputFormatDirective, typeof EqualChildrenDirective, typeof ImageLoaderDirective, typeof ImageUpload, typeof MrouterLinkirective, typeof NegativeNumberOnlyDirective, typeof PSDirective, typeof TranslatorDirective, typeof DragDropFileUploadDirective, typeof FormInvalidClassDirective], [typeof EqualChildrenDirective, typeof ImageLoaderDirective, typeof ImageUpload, typeof MrouterLinkirective, typeof NegativeNumberOnlyDirective, typeof PSDirective, typeof TranslatorDirective, typeof DragDropFileUploadDirective, typeof FormInvalidClassDirective, typeof InputFormatDirective, typeof ETSResponsivenessDirectiveModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DirectivesModule>;
}

/**
 * Directive that restricts input to integer values only.
 *
 * This directive implements ControlValueAccessor to integrate with Angular forms.
 * It filters out non-numeric characters from input, optionally allowing negative numbers.
 * When the input receives focus and contains only a zero, it clears the field.
 */
declare class IntegerOnlyDirective implements ControlValueAccessor {
    private elemRef;
    /**
     * Controls whether negative numbers are allowed in the input.
     * When true, the negative sign (-) is permitted.
     * @default false
     */
    allowNegativeNumbers: boolean;
    /**
     * Creates an instance of IntegerOnlyDirective.
     * @param elemRef - Reference to the host DOM element
     */
    constructor(elemRef: ElementRef);
    /**
     * Handles the focus event on the input element.
     * If the current value is just zero, clears the input field.
     */
    onFocus(): void;
    /**
     * Handles the input event on the element.
     * Filters out non-numeric characters, optionally allowing the negative sign.
     * Notifies Angular forms about the value change.
     */
    onKeyUp(): void;
    /**
     * Writes a value to the element.
     * Part of the ControlValueAccessor interface.
     * @param value - The value to write to the element
     */
    writeValue(value: string): void;
    /**
     * Registers a callback function that is called when the control's value changes in the UI.
     * Part of the ControlValueAccessor interface.
     * @param fn - The callback function to register
     */
    registerOnChange(fn: any): void;
    /**
     * Registers a callback function that is called when the control receives a blur event.
     * Part of the ControlValueAccessor interface.
     * @param fn - The callback function to register
     */
    registerOnTouched(fn: any): void;
    /**
     * Internal method that is set by registerOnChange to propagate changes back to the form.
     * @param value - The new value
     */
    _onChange(value: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IntegerOnlyDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IntegerOnlyDirective, "[appIntegerOnly]", never, { "allowNegativeNumbers": { "alias": "allowNegativeNumbers"; "required": false; }; }, {}, never, never, false, never>;
}

declare class MHrefDirective {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MHrefDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MHrefDirective, "[mHref]", never, {}, {}, never, never, false, never>;
}

declare class NumberPipe {
    decimalPipe: DecimalPipe;
    uS: UtilityService;
    /**
     * @param value The value to be formatted.
     * @param digitsInfo Sets digit and decimal representation.
     * [See more](#digitsinfo).
     */ transform(value: number | string | null | undefined, digitsInfo?: string): unknown;
    constructor(decimalPipe: DecimalPipe, uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NumberPipe, "libNumber", true>;
}

/**
 * Converts form schema to table columns
 */
declare class FormSchemaToTableColumnsPipe implements PipeTransform {
    /**
     * Converts form schema to table columns configuration
     * @param value Array of form schema definitions
     * @returns Array of table column configurations
     */
    transform(value: IFormSchema[]): ITableCol[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormSchemaToTableColumnsPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FormSchemaToTableColumnsPipe, "formSchemaToCols", true>;
}
/**
 * Converts a form.value to string
 */
declare class FormValuePipe implements PipeTransform {
    uS: UtilityService;
    /**
     * Converts a form.value to string
     */
    transform(formValue: any, formSchema?: IFormSchema[]): string;
    /**
     * Converts a form.value to string
     */
    transform<T>(formValue: T, formSchema?: (keyof T)[]): string;
    constructor(uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormValuePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FormValuePipe, "formValue", true>;
}

/**
 * Converts an object to an array of labels for display
 */
declare class ObjectToLabelsPipe implements PipeTransform {
    uS: UtilityService;
    /**
     * Converts an object to an array of labels with optional custom field mapping
     * @param value The source object to convert
     * @param customFieldMap Optional mapping of object keys to ITextCase2 properties
     * @param exclusionList Optional map of field names to exclude
     * @returns Array of ITextCase2 objects representing the object's fields
     */
    transform<T>(value: T, customFieldMap?: {
        [k in keyof T]: Partial<ITextCase2>;
    }, exclusionList?: {
        [x: string]: boolean;
    }): ITextCase2[];
    constructor(uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectToLabelsPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ObjectToLabelsPipe, "objectToLabels", true>;
}

/**
 * Core application service that manages system state, navigation menus, and UI theming.
 * @template TESystem - The system enum type (defaults to ESystem)
 * @template TESystemBusLine - The system bus line enum type (defaults to ESystemBusLine)
 * @template TMenuItem - The menu item type (defaults to ETSMenuItem)
 */
declare class AppService<TESystem = ESystem, TESystemBusLine = ESystemBusLine, TMenuItem = ETSMenuItem> {
    readonly titleS: Title;
    readonly translator: ETSTranslationService;
    /** Top-level navigation menu items */
    topMenu: TMenuItem[];
    /** Sub-menu items for the currently selected top menu */
    bottomMenu: TMenuItem[];
    private _currentTopMenu;
    /** Signal for the currently selected top menu item */
    readonly currentTopMenuSignal: _angular_core.WritableSignal<TMenuItem>;
    private _system;
    private _systemSignal;
    /** Computed signal that provides the current system */
    systemSignal: _angular_core.Signal<TESystem>;
    private _pageName;
    /** Computed signal that provides the current page name */
    readonly pageNameSignal: _angular_core.Signal<string>;
    /**
     * Gets the current system
     * @returns The current system
     */
    get system(): TESystem;
    /**
     * Sets the current system and updates related UI elements
     * @param value - The system to set as current
     */
    set system(value: TESystem);
    /**
     * Gets the currently selected top menu item
     * @returns The current top menu item
     */
    get currentTopMenu(): TMenuItem;
    /**
     * Sets the current top menu item and updates the bottom menu
     * @param value - The menu item to set as current
     */
    set currentTopMenu(value: TMenuItem);
    /**
     * Sets the current top menu based on the provided system
     * @param system - The system to find the corresponding menu item for
     */
    setCurrentTopMenu(system: TESystem): Promise<void>;
    /** Map of system metadata keyed by system enum value */
    systemMetadataMap: Map<TESystem, ISystem<ESystem, ESystemBusLine>>;
    /**
     * Gets the first available system from the environment configuration
     * @returns The first available system's metadata
     */
    get getFirstAvailableSystem(): ISystem<ESystem, ESystemBusLine>;
    /**
     * Gets the metadata for the current system
     * @returns The current system's metadata
     */
    get getCurrentSystemMetadata(): ISystem<ESystem, ESystemBusLine>;
    constructor();
    /**
     * Sets the default CSS class on the body element based on the first available system
     */
    setDefaultClass(): void;
    /**
     * Gets the bus line for the current system
     * @returns The current system's bus line
     */
    get busLine(): ESystemBusLine;
    /**
     * Gets the list of active systems filtered by environment configuration
     * @returns Array of active top menu items
     */
    get activeSystems(): TMenuItem[];
    /**
     * Checks if the current system has a bus line
     * @returns True if the current system has a bus line, false otherwise
     */
    get hasBusLine(): boolean;
    /**
     * Gets the current page name
     * @returns The current page name
     */
    get pageName(): string;
    /**
     * Sets the current page name and updates the document title
     * @param value - The page name to set
     */
    set pageName(value: string);
    /**
     * Updates the document title with the current page name
     * @param title - The title to set
     * @param translate - Whether to translate the title (defaults to true if translation is configured)
     */
    addTitle(title: string, translate?: boolean): void;
    /**
     * Sets the theme color meta tag based on the current system's color code
     */
    setMetaTheme(): void;
    /** Function to filter navigation menu items */
    filterNavMenuFunc: (value: TMenuItem) => boolean;
    /** Available bus lines for the application */
    busLines: IValueLabel<TESystemBusLine>[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppService<any, any, any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AppService<any, any, any>>;
}

/**
 * Service for generating HTML elements as strings
 * Provides utility methods to create HTML markup programmatically
 */
declare class HtmlerService {
    constructor();
    /**
     * Creates an HTML span element with the provided content and optional CSS class
     *
     * @param label - The text content to be displayed inside the span
     * @param cls - Optional CSS class to apply to the span element
     * @returns A string containing the HTML span element
     */
    span: (label: string | number, cls?: string) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HtmlerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HtmlerService>;
}

/**
 * Base service class that provides common NgRx functionality for facade services.
 * Handles dispatching actions and selecting state with additional utilities.
 */
declare abstract class BaseFacadeService {
    protected store: Store<any>;
    protected actions: Actions<any>;
    constructor();
    /**
     * Converts an NgRx action flow into a Promise.
     * Dispatches the provided action and returns a Promise that resolves with the success action's result
     * or rejects with the error action's error.
     *
     * @param dispatchFunc - The action to dispatch to initiate the flow
     * @param config - Configuration object containing success and error action creators
     * @param config.success - Action creator for the success action that contains the result
     * @param config.error - Action creator for the error action that contains the error
     * @returns Promise that resolves with the result of the success action or rejects with the error
     * @template T - The type of the result data
     */
    ngrxPromise<T>(dispatchFunc: Action<any>, config: {
        success: ActionCreator<string, (props: {
            result: T;
        }) => typeof props>;
        error: ActionCreator<string, (props: {
            error: any;
        }) => typeof props>;
    }): Promise<T>;
    /**
     * Selects data from the store and automatically dispatches an action if the selected data is empty.
     * Empty is defined as null, undefined, or an empty array.
     *
     * @param selector$ - Observable selector that retrieves data from the store
     * @param dispatchIfEmpty - Action to dispatch if the selected data is empty
     * @returns The original selector observable with added side effect for dispatching
     * @template T - The type of data being selected
     */
    protected select<T>(selector$: Observable<T>, dispatchIfEmpty: Action<any>): Observable<T>;
}

/**
 * Base service that provides common HTTP operations with standardized URL formatting.
 * Extends this class to create specific API services with a consistent interface.
 */
declare class BaseService {
    /** API service for making HTTP requests */
    protected apiS: ApiService;
    /** Base URL for all API requests from this service */
    protected readonly baseURL: string;
    private _baseURLNoSlash;
    protected get baseURLNoSlash(): string;
    /**
     * Performs a POST request to the specified path
     * @param data - The payload to send in the request body
     * @param path - The path to append to the base URL
     * @returns An Observable of the response
     */
    protected post<T>(data?: any, path?: string | number): rxjs.Observable<T>;
    /**
     * Performs a PUT request to the specified path
     * @param data - The payload to send in the request body
     * @param path - The path to append to the base URL
     * @returns An Observable of the response
     */
    protected put<T>(data?: any, path?: string | number): rxjs.Observable<T>;
    /**
     * Performs a GET request to the specified path
     * @param path - The path to append to the base URL
     * @param query - Query parameters to include in the request
     * @returns An Observable of the response
     */
    protected get<T>(path?: string | number, query?: any): rxjs.Observable<T>;
    /**
     * Performs a DELETE request to the specified path
     * @param path - The path to append to the base URL
     * @param query - Query parameters or body payload for the request
     * @returns An Observable of the response
     */
    protected delete<T>(path?: string | number, query?: any): rxjs.Observable<any>;
    /**
     * Performs a DELETE request with a request body
     * @param path - The path to append to the base URL
     * @param body - The payload to send in the request body
     * @returns An Observable of the response
     */
    protected deleteWithBody<T>(path?: string, body?: any): rxjs.Observable<any>;
    /**
     * POST file with an Object literal as the paramater.
     *
     * The object literal gets converted to a formdata internally before posting.
     * @param path
     * @param body
     * @returns
     */
    protected postFile<T>(path: string, body: IObjectLiteral): rxjs.Observable<T>;
    /**
     * POST file with Formdata as the paramater
     * @param path
     * @param formData
     * @returns
     */
    protected postFileFD<T>(path: string, formData: FormData): rxjs.Observable<T>;
    /**
     * Performs a PUT request with FormData
     * @param path - The path to append to the base URL
     * @param body - The FormData to send in the request
     * @returns An Observable of the response
     */
    protected putFileFD<T>(path: string, body: FormData): rxjs.Observable<T>;
    /**
     * Formats a route by removing trailing slashes
     * @param route - The route to format
     * @returns The formatted route without trailing slash
     */
    formatRoute: (route: string) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BaseService>;
}

/**
 * Abstract base class for NgRx effects.
 *
 * Provides common functionality and dependencies for effect classes.
 * Extend this class to create specific effect implementations.
 */
declare abstract class BaseEffect {
    /**
     * Observable of all actions dispatched in the store.
     * Used to filter and respond to specific actions.
     */
    protected actions$: Actions<any>;
    /**
     * The NgRx store instance.
     * Provides access to the current state and allows dispatching actions.
     */
    protected store: Store<any>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseEffect, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BaseEffect>;
}

/**
 * Service for tracking and managing Angular router state changes.
 * Provides observables and signals to monitor navigation events.
 */
declare class AppRouteService {
    /** Angular Router instance */
    router: Router;
    /** Current ActivatedRoute instance */
    route: ActivatedRoute;
    /** Subject that emits the current route state */
    protected _state: ReplaySubject<{
        state: AppRouteState;
    }>;
    /**
     * Observable that tracks router events and emits the current route
     * after navigation is complete.
     */
    protected routeChangeObservable: rxjs.Observable<ActivatedRoute>;
    /**
     * Observable that emits the current route state when it changes
     * @returns Observable of the current route state
     */
    get state(): rxjs.Observable<{
        state: AppRouteState;
    }>;
    /**
     * Observable that emits when navigation has completed
     * @returns Observable that emits when navigation reaches the completed state
     */
    get completed(): rxjs.Observable<{
        state: AppRouteState;
    }>;
    /**
     * Observable that emits when navigation has started
     * @returns Observable that emits when navigation reaches the started state
     */
    get started(): rxjs.Observable<{
        state: AppRouteState;
    }>;
    /**
     * Observable that emits when navigation is ongoing
     * @returns Observable that emits when navigation reaches the ongoing state
     */
    get ongoing(): rxjs.Observable<{
        state: AppRouteState;
    }>;
    /** Signal that holds the current activated route */
    currentRouteSignal: _angular_core.WritableSignal<ActivatedRoute>;
    /** Flag to track if the service has started listening to route changes */
    protected startedListening: boolean;
    constructor();
    /**
     * Returns the observable that emits the current route after navigation
     * @returns Observable of the current activated route
     */
    get observable(): rxjs.Observable<ActivatedRoute>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppRouteService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AppRouteService>;
}
/**
 * Enum representing the different states of a route navigation
 */
declare enum AppRouteState {
    /** Navigation has started */
    started = "STARTED",
    /** Navigation has completed successfully */
    completed = "COMPLETED",
    /** Navigation was cancelled */
    cancelled = "CANCELLED",
    /** Navigation is in progress */
    ongoing = "ONGOING"
}

/**
 * Service responsible for managing application theming elements such as
 * favicon, title, and meta tags based on environment configuration.
 */
declare class ETSThemeService {
    constructor();
    /**
     * Initializes the theme by setting up favicon, title, and meta tags.
     */
    setup(): void;
    /**
     * Sets meta tags for the application.
     * Note: Currently this method only retrieves the HTML element without setting any meta tags.
     */
    setMeta(): void;
    /**
     * Sets the application favicon based on the environment configuration.
     * Looks for an element with id 'favicon' in the document head and updates its href.
     */
    setFavicon(): void;
    /**
     * Sets the application title based on the environment configuration.
     * Updates the content of the title element in the document.
     */
    setTitle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSThemeService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSThemeService>;
}

declare class ETSWindowSecurityService {
    uS: UtilityService;
    constructor(uS: UtilityService);
    startTabCheck(singleTabUsage: boolean): void;
    useOtherSingleTabCheck(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSWindowSecurityService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSWindowSecurityService>;
}

/**
 * Service that prompts users when updates are available.
 * Displays a confirmation dialog asking users to reload the application.
 */
declare class ETSPromptUpdateService {
    cS: ETSConfirmDialogService;
    /**
     * Controls whether the update prompt dialog should be displayed.
     * When set to false, the service will not show any update prompts.
     *
     * @example
     * ```typescript
     * // Disable update prompts
     * promptUpdateService.showPrompt = false;
     *
     * // Enable update prompts (default)
     * promptUpdateService.showPrompt = true;
     *
     * // Conditionally show prompts based on user preferences
     * if (userSettings.allowUpdatePrompts) {
     *   promptUpdateService.showPrompt = true;
     * } else {
     *   promptUpdateService.showPrompt = false;
     * }
     * ```
     */
    showPrompt: boolean;
    /**
     * Indicates whether the confirmation prompt dialog is currently open
     */
    isOpen: boolean;
    /**
     * Reference to the prompt dialog for managing its lifecycle
     */
    promptRef: MatDialogRef<ConfirmDialogComponent, any>;
    /**
     * Subscription to the dialog's afterClosed event
     */
    promptSub: Subscription;
    /**
     * Creates an instance of ETSPromptUpdateService.
     * Sets up a subscription to VERSION_READY events from the SwUpdate service.
     *
     * @param swUpdate - SwUpdate service to listen for version updates
     * @param cS - Confirmation dialog service to display prompts to the user
     */
    constructor(swUpdate: SwUpdate, cS: ETSConfirmDialogService);
    /**
     * Displays a prompt to the user asking to reload the application.
     * If a prompt is already open, it will be closed before showing a new one.
     *
     * @param reason - Optional reason to display in the prompt explaining why a reload is needed
     */
    prompter(reason?: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSPromptUpdateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSPromptUpdateService>;
}

/**
 * Service responsible for checking for application updates at regular intervals.
 * It uses Angular's SwUpdate service to detect when new versions are available.
 */
declare class ETSCheckForUpdateService {
    appRef: ApplicationRef;
    updates: SwUpdate;
    sS: ETSStorageService;
    puS: ETSPromptUpdateService;
    /**
     * Creates an instance of ETSCheckForUpdateService.
     * @param appRef - Angular's ApplicationRef to detect application stability
     * @param updates - SwUpdate service to check for and handle updates
     * @param sS - Storage service to save update check timestamps
     * @param puS - Service to prompt users about available updates
     */
    constructor(appRef: ApplicationRef, updates: SwUpdate, sS: ETSStorageService, puS: ETSPromptUpdateService);
    /**
     * Initializes the update checking mechanism.
     * Waits for the application to stabilize before starting regular update checks.
     *
     * @param itvl - Interval in milliseconds between update checks (defaults to 30 minutes)
     * @param cb - Optional callback function to execute when an update is found
     */
    init(itvl?: number, cb?: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSCheckForUpdateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSCheckForUpdateService>;
}

/**
 * Service that handles unrecoverable states in the service worker.
 * When the service worker encounters a state it cannot recover from,
 * this service will prompt the user with information about the error.
 */
declare class ETSHandleUnrecoverableStateService {
    uS: UtilityService;
    puS: ETSPromptUpdateService;
    /**
     * Creates an instance of ETSHandleUnrecoverableStateService.
     * Sets up a subscription to the unrecoverable events from the SwUpdate service.
     *
     * @param updates - SwUpdate service to listen for unrecoverable states
     * @param uS - Utility service for common operations
     * @param puS - Service to prompt users about the unrecoverable state
     */
    constructor(updates: SwUpdate, uS: UtilityService, puS: ETSPromptUpdateService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSHandleUnrecoverableStateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSHandleUnrecoverableStateService>;
}

/**
 * Service that logs information about service worker updates.
 * Monitors different update states and provides appropriate notifications.
 */
declare class ETSLogUpdateService {
    uS: UtilityService;
    /**
     * Creates an instance of ETSLogUpdateService.
     * Sets up a subscription to version update events from the SwUpdate service.
     *
     * @param updates - SwUpdate service to listen for version updates
     * @param uS - Utility service for notifications and common operations
     */
    constructor(updates: SwUpdate, uS: UtilityService);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSLogUpdateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSLogUpdateService>;
}

/**
 * Main service worker service that coordinates all service worker functionality.
 * Provides methods to manually check for updates and integrates all other service worker services.
 */
declare class ETSServiceWorkerService {
    puS: ETSPromptUpdateService;
    luS: ETSLogUpdateService;
    huS: ETSHandleUnrecoverableStateService;
    cfuS: ETSCheckForUpdateService;
    sS: ETSStorageService;
    iS: InfoDialogService;
    /**
     * Creates an instance of ETSServiceWorkerService.
     *
     * @param puS - Service to prompt users about available updates
     * @param luS - Service to log update information
     * @param huS - Service to handle unrecoverable states
     * @param cfuS - Service to check for updates
     * @param sS - Storage service to save update check timestamps
     * @param iS - Info dialog service to display information to users
     */
    constructor(puS: ETSPromptUpdateService, luS: ETSLogUpdateService, huS: ETSHandleUnrecoverableStateService, cfuS: ETSCheckForUpdateService, sS: ETSStorageService, iS: InfoDialogService);
    /**
     * Manually checks for application updates.
     * Waits for the application to be stable before checking.
     * Displays appropriate messages based on whether updates are found.
     *
     * @param cb - Optional callback function to execute after the update check completes
     */
    getUpdates(cb?: any): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSServiceWorkerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ETSServiceWorkerService>;
}

/**
 * Injection token for the default timeout value in milliseconds
 */
declare const DEFAULT_TIMEOUT: InjectionToken<number>;
/**
 * Interceptor service that adds timeout functionality to HTTP requests.
 * Cancels requests that take longer than the configured timeout period.
 */
declare class RequestTimeoutInterceptorService {
    protected defaultTimeout: number;
    /**
     * Creates an instance of RequestTimeoutInterceptorService.
     *
     * @param defaultTimeout - The default timeout value in milliseconds
     */
    constructor(defaultTimeout: number);
    /**
     * Intercepts HTTP requests to add timeout functionality.
     * Uses different timeout values for production and development environments.
     *
     * @param req - The outgoing HTTP request
     * @param next - The next interceptor in the chain
     * @returns An observable of the HTTP event stream
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequestTimeoutInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RequestTimeoutInterceptorService>;
}

/**
 * Interceptor service that manages loading indicators during HTTP requests.
 * Shows and hides page loaders based on active HTTP requests.
 */
declare class RequestLoggerInterceptorService implements HttpInterceptor {
    /**
     * Creates an instance of RequestLoggerInterceptorService.
     */
    constructor();
    /**
     * Intercepts HTTP requests to manage loading indicators.
     * Starts the page loader when a request begins and stops it when the request completes.
     *
     * @param req - The outgoing HTTP request
     * @param next - The next interceptor in the chain
     * @returns An observable of the HTTP event stream
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequestLoggerInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RequestLoggerInterceptorService>;
}

/**
 * Interceptor service that logs HTTP requests and responses.
 * Provides detailed logging for debugging and monitoring purposes.
 */
declare class LoggerInterceptorService implements HttpInterceptor {
    loggerS: LoggerService;
    /**
     * List of API endpoints that are exempt from logging
     */
    readonly exemptList: string[];
    /**
     * Creates an instance of LoggerInterceptorService.
     * Converts all exempt URLs to lowercase for consistent comparison.
     *
     * @param loggerS - The logger service for storing logs
     */
    constructor(loggerS: LoggerService);
    /**
     * Intercepts HTTP requests to log them and their responses.
     * Skips logging for exempt endpoints or when debugging is disabled.
     *
     * @param req - The outgoing HTTP request
     * @param next - The next interceptor in the chain
     * @returns An observable of the HTTP event stream
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoggerInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoggerInterceptorService>;
}

/**
 * Global error handler service that processes application-wide errors.
 * Handles specific error types differently and integrates with error reporting.
 */
declare class GlobalErrorHandlerService extends ErrorHandler {
    /**
     * Service for reporting errors to external systems
     */
    errorReporterService: ErrorReporterService;
    /**
     * Creates an instance of GlobalErrorHandlerService.
     */
    constructor();
    /**
     * Handles errors thrown in the application.
     * - Ignores ExpressionChangedAfterItHasBeenCheckedError
     * - Reloads the page for chunk loading failures
     * - Passes other errors to the default handler
     *
     * @param error - The error object to handle
     */
    handleError(error: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GlobalErrorHandlerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GlobalErrorHandlerService>;
}

/**
 * Interceptor service that handles authentication for API requests.
 * Adds authorization headers to requests and handles 401 unauthorized responses.
 */
declare class AuthenticationInterceptorService implements HttpInterceptor {
    router: Router;
    /**
     * Creates an instance of AuthenticationInterceptorService.
     * @param router - Angular router for navigation after authentication failures
     */
    constructor(router: Router);
    /**
     * Intercepts HTTP requests to add authentication headers when required.
     * Redirects to login page on 401 unauthorized responses.
     *
     * @param req - The outgoing HTTP request
     * @param next - The next interceptor in the chain
     * @returns An observable of the HTTP event stream
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthenticationInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthenticationInterceptorService>;
}

declare class CacheUpdaterService {
    apiService: ApiService;
    constructor(apiService: ApiService);
    update: (cacheS: CacheService) => rxjs.Observable<rxjs.Subscription>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CacheUpdaterService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CacheUpdaterService>;
}

declare class SaverClass {
    private readonly itemName;
    private readonly storageKey;
    /**
     * Storage Service
     */
    storageService: StorageClass;
    /**
     *
     * @param itemName Field name of the item
     * @param storageKey  The key used for the storage slot assigned to the item
     */
    constructor(itemName: string, storageKey: string);
    /**
     * Save Item to storage
     */
    saveToLocal(): void;
    /**
     * Get Item from storage
     */
    getFromLocal(): void;
}
declare class SaverService extends SaverClass {
    /**
     *
     * @param itemName Field name of the item
     * @param storageKey  The key used for the storage slot assigned to the item
     */
    constructor(itemName: string, storageKey: string);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SaverService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SaverService>;
}

/**
 * Environment configuration for the application.
 *
 * This constant defines the environment settings for the development environment.
 * It creates a new Environment instance with parameters:
 * @param {boolean} false - Indicates this is not a production environment
 * @param {string} 'Development' - The name of the current environment
 */
declare const environment: Environment;

declare const _SharedModule: readonly [typeof ets_fe_ng_sdk.BtnComponent, typeof ets_fe_ng_sdk.BtnLgComponent, typeof ets_fe_ng_sdk.AutocompleteComponent, typeof ets_fe_ng_sdk.AutocompleteTdRfComponent, typeof ets_fe_ng_sdk.BtnComponent, typeof ets_fe_ng_sdk.BtnLgComponent, typeof ets_fe_ng_sdk.DayHourMinInputComponent, typeof _angular_forms.FormsModule, typeof ets_fe_ng_sdk.InputBasicComponent, typeof ets_fe_ng_sdk.InputComponent, typeof ets_fe_ng_sdk.InputControlComponent, typeof ets_fe_ng_sdk.InputLabelComponent, typeof ets_fe_ng_sdk.InputPipesModule, typeof ets_fe_ng_sdk.InputTD_RFComponent, typeof MatTooltipModule, typeof _angular_forms.ReactiveFormsModule, typeof ets_fe_ng_sdk.ValidationMessageComponent, typeof ets_fe_ng_sdk.YearMonthTdRfComponent, typeof ets_fe_ng_sdk.AutocompleteComponent, typeof ets_fe_ng_sdk.AutocompleteTdRfComponent, typeof AddItemComponent, typeof CardComponent, typeof CommonModule, typeof ButtonComponent, typeof DetailsBtnComponent, typeof DirectivesModule, typeof DocumentsNameDisplayComponent, typeof EditableTextCaseComponent, typeof ExportTableComponent, typeof FontAwesomeModule, typeof FormErrorComponent, typeof FormGeneratorComponent, typeof FormLinkComponent, typeof FormTabHeadersComponent, typeof InfoIconComponent, typeof InputNGModelComponent, typeof LabelComponent, typeof LoaderComponent, typeof MatButtonModule, typeof MatDialogModule, typeof MatExpansionModule, typeof MatMenuModule, typeof MatTooltipModule, typeof ModalComponent, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof ets_fe_ng_sdk.ModalBodyDirective, typeof ets_fe_ng_sdk.ModalFooterDirective, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof ModalComponent, typeof PageTemplateComponent, typeof PageToComponentComponent, typeof PhoneNumberComponent, typeof RouterModule, typeof RowActionsComponent, typeof SvgIconComponent, typeof TablePlainComponent, typeof TableHttpsComponent, typeof TextCase1Component, typeof TextCase2Component, typeof TextCaseInputComponent, typeof TextComponent, typeof UtilityPipesModule, typeof ViewFormButtonsComponent, typeof TranslatorCaseComponent];
declare class SharedModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SharedModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SharedModule, never, [typeof i1$1.CommonModule, typeof BtnComponent, typeof BtnLgComponent, typeof AutocompleteComponent, typeof AutocompleteTdRfComponent, typeof BtnComponent, typeof BtnLgComponent, typeof DayHourMinInputComponent, typeof _angular_forms.FormsModule, typeof InputBasicComponent, typeof InputComponent, typeof InputControlComponent, typeof InputLabelComponent, typeof InputPipesModule, typeof InputTD_RFComponent, typeof i14.MatTooltipModule, typeof _angular_forms.ReactiveFormsModule, typeof ValidationMessageComponent, typeof YearMonthTdRfComponent, typeof AutocompleteComponent, typeof AutocompleteTdRfComponent, typeof AddItemComponent, typeof CardComponent, typeof i1$1.CommonModule, typeof ButtonComponent, typeof DetailsBtnComponent, typeof DirectivesModule, typeof DocumentsNameDisplayComponent, typeof EditableTextCaseComponent, typeof ExportTableComponent, typeof i25.FontAwesomeModule, typeof FormErrorComponent, typeof FormGeneratorComponent, typeof FormLinkComponent, typeof FormTabHeadersComponent, typeof InfoIconComponent, typeof InputNGModelComponent, typeof LabelComponent, typeof LoaderComponent, typeof i34.MatButtonModule, typeof _angular_material_dialog.MatDialogModule, typeof i36.MatExpansionModule, typeof i37.MatMenuModule, typeof i14.MatTooltipModule, typeof ModalComponent, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof ModalBodyDirective, typeof ModalFooterDirective, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof ModalComponent, typeof PageTemplateComponent, typeof PageToComponentComponent, typeof PhoneNumberComponent, typeof i1.RouterModule, typeof RowActionsComponent, typeof SvgIconComponent, typeof TablePlainComponent, typeof TableHttpsComponent, typeof TextCase1Component, typeof TextCase2Component, typeof TextCaseInputComponent, typeof TextComponent, typeof UtilityPipesModule, typeof ViewFormButtonsComponent, typeof TranslatorCaseComponent], [typeof BtnComponent, typeof BtnLgComponent, typeof AutocompleteComponent, typeof AutocompleteTdRfComponent, typeof BtnComponent, typeof BtnLgComponent, typeof DayHourMinInputComponent, typeof _angular_forms.FormsModule, typeof InputBasicComponent, typeof InputComponent, typeof InputControlComponent, typeof InputLabelComponent, typeof InputPipesModule, typeof InputTD_RFComponent, typeof i14.MatTooltipModule, typeof _angular_forms.ReactiveFormsModule, typeof ValidationMessageComponent, typeof YearMonthTdRfComponent, typeof AutocompleteComponent, typeof AutocompleteTdRfComponent, typeof AddItemComponent, typeof CardComponent, typeof i1$1.CommonModule, typeof ButtonComponent, typeof DetailsBtnComponent, typeof DirectivesModule, typeof DocumentsNameDisplayComponent, typeof EditableTextCaseComponent, typeof ExportTableComponent, typeof i25.FontAwesomeModule, typeof FormErrorComponent, typeof FormGeneratorComponent, typeof FormLinkComponent, typeof FormTabHeadersComponent, typeof InfoIconComponent, typeof InputNGModelComponent, typeof LabelComponent, typeof LoaderComponent, typeof i34.MatButtonModule, typeof _angular_material_dialog.MatDialogModule, typeof i36.MatExpansionModule, typeof i37.MatMenuModule, typeof i14.MatTooltipModule, typeof ModalComponent, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof ModalBodyDirective, typeof ModalFooterDirective, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof ModalComponent, typeof PageTemplateComponent, typeof PageToComponentComponent, typeof PhoneNumberComponent, typeof i1.RouterModule, typeof RowActionsComponent, typeof SvgIconComponent, typeof TablePlainComponent, typeof TableHttpsComponent, typeof TextCase1Component, typeof TextCase2Component, typeof TextCaseInputComponent, typeof TextComponent, typeof UtilityPipesModule, typeof ViewFormButtonsComponent, typeof TranslatorCaseComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SharedModule>;
}

/**
 * Component for displaying and managing application logs.
 * Provides functionality to view, copy, download logs and manage authentication.
 */
declare class LoggerComponent implements OnInit {
    lS: LoggerService;
    uS: UtilityService;
    /** Reference to handle component destruction and cleanup */
    protected destroyRef: DestroyRef;
    /** Computed property that returns reversed logs for display */
    readonly logs: _angular_core.Signal<Log<any>[]>;
    /**
     * Creates an instance of LoggerComponent.
     * Sets up an interval to fetch logs every second.
     *
     * @param lS - Logger service for managing logs
     * @param uS - Utility service for notifications and downloads
     */
    constructor(lS: LoggerService, uS: UtilityService);
    /**
     * Initializes the component and checks authentication.
     * Prompts for password if not authenticated.
     */
    ngOnInit(): void;
    /**
     * Tracking function for NgFor to improve performance.
     *
     * @param index - The index of the current item
     * @param item - The log item
     * @returns The unique identifier for the log
     */
    trackByID(index: number, item: Log): string;
    /**
     * Copies log data to clipboard.
     *
     * @param i - Index of the log to copy
     */
    copy(i: number): void;
    /**
     * Downloads log data as a file.
     *
     * @param i - Index of the log to download
     */
    download(i: number): void;
    /**
     * Locks the logger interface.
     */
    lock(): void;
    /**
     * Displays notification when content is copied to clipboard.
     */
    copied(): void;
    /**
     * Displays notification when log is downloaded.
     */
    downloaded(): void;
    /**
     * Creates a downloadable text file from log data.
     *
     * @param log - The log object to convert to a file
     * @returns A function that creates and downloads the file
     */
    makeTextFile: (log: Log) => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoggerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoggerComponent, "app-logger", never, {}, {}, never, never, true, never>;
}

declare class LoggerRoutingModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoggerRoutingModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<LoggerRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<LoggerRoutingModule>;
}

declare class ETSLoggerModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSLoggerModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ETSLoggerModule, never, [typeof i1$1.CommonModule, typeof LoggerRoutingModule, typeof SharedModule, typeof i4.ClipboardModule, typeof LoggerComponent], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ETSLoggerModule>;
}

declare class ETSPageNotFoundComponent {
    route: ActivatedRoute;
    uS: UtilityService;
    domSanitizer: DomSanitizer;
    readonly config: _angular_core.Signal<IPageErrorConfig>;
    readonly configMessage: _angular_core.Signal<string>;
    readonly configBtn: _angular_core.Signal<Btn<any>>;
    readonly btnCaseClass: _angular_core.WritableSignal<string>;
    constructor(route: ActivatedRoute, uS: UtilityService, domSanitizer: DomSanitizer);
    back(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSPageNotFoundComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ETSPageNotFoundComponent, "app-page-not-found", never, {}, {}, never, never, true, never>;
}
declare const pageErrorRouter: (config: {
    route: Route;
    dataConfig: IPageErrorConfig;
}) => Route;
interface IPageErrorConfig {
    status?: string | number;
    message?: string;
    hideButtons?: boolean;
    btn?: Btn;
}

declare class RobotRoutingModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RobotRoutingModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RobotRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RobotRoutingModule>;
}

declare class RobotComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RobotComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RobotComponent, "app-robot", never, {}, {}, never, never, true, never>;
}

declare class ETSRobotModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSRobotModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ETSRobotModule, never, [typeof i1$1.CommonModule, typeof RobotRoutingModule, typeof RobotComponent], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ETSRobotModule>;
}

/**
 * Interface that defines which fields of a query object should be shown in the UI
 *
 * @template TQuery - The type of the query object, defaults to any
 * @property {boolean} [field] - For each field in TQuery, indicates whether it should be shown (true) or hidden (false/undefined)
 */
type IFindItemShownFields<TQuery = any> = {
    [field in keyof TQuery]?: boolean;
};

/**
 * Service for managing find-item component field selections.
 * Handles saving and retrieving user-selected fields for find-item components.
 */
declare class FindItemService {
    sS: ETSStorageService;
    /**
     * Creates an instance of FindItemService.
     * @param sS - The storage service used to persist field selections
     */
    constructor(sS: ETSStorageService);
    /**
     * Generates a unique storage key for a specific find-item component.
     * @param id - The unique identifier for the find-item component
     * @returns A storage key string prefixed with 'find-item-fields-'
     */
    idKeyer: (id: string) => string;
    /**
     * Saves the selected fields configuration for a find-item component.
     * @template TQuery - The type of query object used by the find-item component
     * @param id - The unique identifier for the find-item component
     * @param fields - The field configuration to be saved
     * @returns The result of the storage operation
     */
    saveSelectedCompactedFields<TQuery>(id: string, fields: IFindItemShownFields<TQuery>): any;
    /**
     * Retrieves previously saved field configurations for a find-item component.
     * @template TQuery - The type of query object used by the find-item component
     * @param id - The unique identifier for the find-item component
     * @returns The saved field configuration, or null if none exists
     */
    getSavedSelectedCompactedFields<TQuery>(id: string): IFindItemShownFields<TQuery>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FindItemService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FindItemService>;
}

declare class widthOffsetPipe implements PipeTransform {
    transform(width: number): number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<widthOffsetPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<widthOffsetPipe, "widthOffsetPipe", true>;
}
/**
 * A reusable component for searching and displaying items in a table format.
 * Supports both client-side and server-side searching, pagination, and various display options.
 *
 * @template TQuery - The type of the search query object
 * @template TRow - The type of the row data object
 */
declare class FindItemComponent<TQuery extends IObjectLiteral = any, TRow extends IObjectLiteral = any> extends BaseFormGenerator<TQuery, ISearchFormSchema<TQuery, TRow>> implements OnInit {
    /** Reference to action buttons in the template */
    readonly actionBtns: _angular_core.Signal<readonly ElementRef<HTMLSpanElement>[]>;
    /** Computed map of action button element IDs */
    readonly fieldWidthOffsets: _angular_core.Signal<{
        [x: string]: ElementRef<HTMLSpanElement>;
    }>;
    /** Effect to log action buttons when they change */
    readonly actionBtnsEffect: _angular_core.EffectRef;
    /**
     * Whether to automatically format the schema based on field types
     */
    readonly autoFormatSchema: _angular_core.InputSignal<boolean>;
    /** Unique identifier for this component instance */
    readonly id: _angular_core.InputSignal<string>;
    /** Whether to automatically order form fields */
    readonly autoOrder: _angular_core.InputSignal<boolean>;
    readonly enableRowClick: _angular_core.InputSignal<boolean>;
    /** Text to display on the search button */
    readonly searchButtonText: _angular_core.InputSignal<string>;
    /** Icon to display on the search button */
    readonly searchButtonIcon: _angular_core.InputSignal<IconType>;
    /** Whether to center cell content in the table */
    readonly centerCells: _angular_core.InputSignal<boolean>;
    /** Columns to display in the table */
    readonly _displayedColumns: _angular_core.InputSignal<TableCol<TRow>[]>;
    /** Computed columns with optional label formatting */
    readonly displayedColumns: _angular_core.Signal<TableCol<TRow>[]>;
    /**
     * CSS class for grid layout configuration
     */
    readonly gridClass: _angular_core.InputSignal<string>;
    /** Whether to hide the search form */
    readonly hideForm: _angular_core.InputSignal<boolean>;
    /** Custom templates for table cells */
    readonly customTableCellTemplates: _angular_core.InputSignal<{ [k in keyof TRow]?: TemplateRef<any>; }>;
    /** Template for expanded rows */
    readonly expandedRowTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Whether the table is paginated */
    readonly isTablePaginated: _angular_core.Signal<boolean>;
    /** Function to map row data to row options */
    readonly rowOptionsMap: _angular_core.InputSignal<(row: TRow) => (IRowOption<TRow> | null)[]>;
    /** Whether rows can be expanded */
    readonly isExpandable: _angular_core.InputSignal<boolean>;
    /** Label for the component */
    readonly label: _angular_core.InputSignal<string>;
    /** Whether to prevent text wrapping in cells */
    readonly nowrap: _angular_core.InputSignal<boolean>;
    /** Options for row actions */
    readonly options: _angular_core.InputSignal<IRowOption<TRow>[]>;
    /** Direction for sorting */
    readonly orderDirection: _angular_core.InputSignal<SortType>;
    /** Field to sort by */
    readonly orderField: _angular_core.InputSignal<keyof TRow>;
    /** Number of items per page */
    readonly pageSize: _angular_core.InputSignal<number>;
    /** Function to perform search and return results */
    readonly searchFunction: _angular_core.InputSignal<(data: any) => Observable<TRow[] | {
        content: TRow[];
    }>>;
    /** Whether to show data in the table */
    readonly showData: _angular_core.InputSignal<boolean>;
    /** Whether to search even if no query parameters are provided */
    readonly searchIfNoQuery: _angular_core.InputSignal<boolean>;
    /** Whether to use compact display mode */
    readonly isCompact: _angular_core.InputSignal<boolean>;
    /** Whether to show export button */
    readonly showExport: _angular_core.InputSignal<boolean>;
    /** Whether to show filter controls */
    readonly showFilter: _angular_core.InputSignal<boolean>;
    /** Whether to show refresh button */
    readonly showRefreshBtn: _angular_core.InputSignal<boolean>;
    /** Whether to use static loader */
    readonly useStaticLoader: _angular_core.InputSignal<boolean>;
    /** Whether to use striped rows in the table */
    readonly striped: _angular_core.InputSignal<boolean>;
    /** Text to display when no search has been performed */
    readonly searchPromptText: _angular_core.InputSignal<string>;
    /** Template for content at the start of the component */
    readonly startSectionTemplate: _angular_core.InputSignal<TemplateRef<HTMLElement>>;
    /** Form group for the search form */
    form: FormGroup;
    /**
     * Whether to show the search button
     */
    readonly showSearchBtn: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show the clear form button
     */
    readonly showClearBtn: _angular_core.InputSignal<boolean>;
    readonly showFormError: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show validation messages
     */
    readonly showValidationMsg: _angular_core.InputSignal<boolean>;
    /** Route for create button */
    readonly createBtnRoute: _angular_core.InputSignal<string>;
    readonly createBtnNoRoute: _angular_core.InputSignal<boolean>;
    readonly createBtnText: _angular_core.InputSignal<string>;
    /**
     * Whether to show additional column selection
     */
    readonly showAdditionalColumns: _angular_core.InputSignal<boolean>;
    /** Whether to use smaller fonts */
    readonly smallerFonts: _angular_core.InputSignal<boolean>;
    /** Whether to use checkboxes for row selection */
    readonly useSelection: _angular_core.InputSignal<boolean>;
    /** Initial query values */
    readonly initialQuery: _angular_core.ModelSignal<{ [k in keyof TQuery]?: TQuery[k]; }>;
    /** Event emitted when a row is clicked */
    readonly _rowClick: _angular_core.OutputEmitterRef<TRow>;
    /** Event emitted when a row is expanded or collapsed */
    readonly clickedExpandRow: _angular_core.OutputEmitterRef<{
        open: boolean;
        row: TRow;
    }>;
    /** Event emitted when create button is clicked */
    readonly clickedCreate: _angular_core.OutputEmitterRef<void>;
    /** Reference to the HTTP table component */
    readonly tableHTTPSREF: _angular_core.Signal<TableHttpsComponent<TRow>>;
    /** Reference to the plain table component */
    readonly tablePlainRef: _angular_core.Signal<TablePlainComponent<TRow>>;
    /** Signal-based reference to the HTTP table component */
    readonly tableHTTPSREFSignal: _angular_core.Signal<TableHttpsComponent<TRow>>;
    /** Signal-based reference to the plain table component */
    readonly tablePlainRefSignal: _angular_core.Signal<TablePlainComponent<TRow>>;
    readonly formErrorRef: _angular_core.Signal<FormErrorComponent>;
    /** Data to display in the table */
    readonly data: _angular_core.WritableSignal<TRow[]>;
    /** Internal loading state */
    protected readonly _loading: _angular_core.WritableSignal<boolean>;
    /** Combined loading state from internal and table loading */
    readonly loading: _angular_core.Signal<boolean>;
    /** Form group for search fields */
    readonly searchForm: _angular_core.Signal<FormGroup<any>>;
    /** Form group for standalone fields */
    readonly standaloneForm: _angular_core.Signal<FormGroup<any>>;
    /**
     * Whether to show create button
     */
    readonly createButton: _angular_core.InputSignal<boolean>;
    /** Function to check if a field is shown in compact mode */
    readonly asfCheckedChecker: _angular_core.WritableSignal<(option: ISearchFormSchema) => boolean>;
    /**
     * Sets the form schema for the component
     */
    set _formSchema(v: ISearchFormSchema<TQuery, TRow>[]);
    /** Function to perform server-side search */
    readonly searchObservableFunc: _angular_core.InputSignal<(data: any) => Observable<ITableSearchResp<TRow>>>;
    /** Delimiter for fields in query string */
    protected readonly delimiterField = "~~~";
    /** Delimiter for words in query string */
    protected readonly delimiterWord = "~~";
    /** Subject to trigger search */
    readonly searchTrigger: Subject<IObjectLiteral<any>>;
    /** Map of fields shown in compact mode */
    readonly showCompactFieldsMap: _angular_core.WritableSignal<IFindItemShownFields<TQuery>>;
    /** Combined map of saved and current compact fields */
    readonly cShowCompactFieldsMap: _angular_core.Signal<IFindItemShownFields<TQuery>>;
    /** Map of saved compact fields */
    readonly savedShowCompactFieldsMap: _angular_core.Signal<IFindItemShownFields<unknown>>;
    /** Computed form schema based on compact mode and visibility */
    readonly _computedFormSchema: _angular_core.Signal<ISearchFormSchema<TQuery, TRow>[]>;
    /** Final computed form schema with form references */
    readonly computedFormSchema: _angular_core.Signal<ISearchFormSchema<TQuery, TRow>[]>;
    /** Fields that can be shown in compact mode */
    readonly compactedFields: _angular_core.Signal<ISearchFormSchema<TQuery, TRow>[]>;
    /** Whether the table has columns */
    protected readonly hasColumns: _angular_core.Signal<boolean>;
    /** Whether to hide the table */
    protected readonly hideTable: _angular_core.Signal<boolean>;
    /** Whether a search has been performed */
    protected searched: _angular_core.WritableSignal<boolean>;
    /** User activity service */
    uaS: UserActivityService;
    /** Router service */
    router: Router;
    /** Activated route */
    route: ActivatedRoute;
    /** Find item service */
    findItemService: FindItemService;
    /** Subscription manager */
    protected readonly subs2: {
        clear: () => void;
        push: (...subs: rxjs.Subscription[]) => number;
        subs: () => rxjs.Subscription[];
    };
    ngOnInit(): void;
    onDestroy(): void;
    toggleCompactField(field: ISearchFormSchema): void;
    readonly tempSelectedCompactedFields: _angular_core.WritableSignal<ISearchFormSchema<any, any>[]>;
    selectedCompactedFields(): void;
    protected saveSelectedCompactedFields(): void;
    fetchSavedQuery(): void;
    init(schema: ISearchFormSchema<TQuery, TRow>[]): void;
    handleAllSchema(schema: ISearchFormSchema<TQuery, TRow>[]): void;
    handleFormScheme(scheme: ISearchFormSchema<TQuery, TRow>): void;
    updateFormSchema(fieldName: keyof TQuery, scheme: Partial<ISearchFormSchema<{
        [k in keyof TQuery]: AbstractControl<any, any> | any;
    }>>): void;
    updateAllFormSchema(map: (formField: ISearchFormSchema<TQuery, TRow>) => ISearchFormSchema<TQuery, TRow>): ISearchFormSchema<TQuery, TRow>[];
    detachFormScheme(fieldName?: keyof TQuery): void;
    readonly searchFormValue: _angular_core.Signal<any>;
    readonly standaloneFormValue: _angular_core.Signal<any>;
    readonly allSearchFormValue: _angular_core.Signal<any>;
    trackByRowID: (index: any, item: any) => any;
    clearFilters(): void;
    refresh(): void;
    search(): void;
    fieldAction(field: ISearchFormSchema): void;
    protected _search(): Promise<void>;
    saveQuery(query?: any): void;
    rowClick(e: TRow): void;
    get selection(): TRow[];
    readonly selectionSignal: _angular_core.Signal<TRow[]>;
    readonly isAnySelected: _angular_core.Signal<boolean>;
    startLoader(): void;
    stopLoader(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FindItemComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FindItemComponent<any, any>, "app-find-item,find-item", never, { "autoFormatSchema": { "alias": "autoFormatSchema"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "autoOrder": { "alias": "autoOrder"; "required": false; "isSignal": true; }; "enableRowClick": { "alias": "enableRowClick"; "required": false; "isSignal": true; }; "searchButtonText": { "alias": "searchButtonText"; "required": false; "isSignal": true; }; "searchButtonIcon": { "alias": "searchButtonIcon"; "required": false; "isSignal": true; }; "centerCells": { "alias": "centerCells"; "required": false; "isSignal": true; }; "_displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "gridClass": { "alias": "gridClass"; "required": false; "isSignal": true; }; "hideForm": { "alias": "hideForm"; "required": false; "isSignal": true; }; "customTableCellTemplates": { "alias": "customTableCellTemplates"; "required": false; "isSignal": true; }; "expandedRowTemplate": { "alias": "expandedRowTemplate"; "required": false; "isSignal": true; }; "rowOptionsMap": { "alias": "rowOptionsMap"; "required": false; "isSignal": true; }; "isExpandable": { "alias": "isExpandable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "nowrap": { "alias": "nowrap"; "required": false; "isSignal": true; }; "options": { "alias": "rowOptions"; "required": false; "isSignal": true; }; "orderDirection": { "alias": "orderDirection"; "required": false; "isSignal": true; }; "orderField": { "alias": "orderField"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "searchFunction": { "alias": "searchFunction"; "required": false; "isSignal": true; }; "showData": { "alias": "showData"; "required": false; "isSignal": true; }; "searchIfNoQuery": { "alias": "searchIfNoQuery"; "required": false; "isSignal": true; }; "isCompact": { "alias": "isCompact"; "required": false; "isSignal": true; }; "showExport": { "alias": "showExport"; "required": false; "isSignal": true; }; "showFilter": { "alias": "showFilter"; "required": false; "isSignal": true; }; "showRefreshBtn": { "alias": "showRefreshBtn"; "required": false; "isSignal": true; }; "useStaticLoader": { "alias": "useStaticLoader"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "searchPromptText": { "alias": "searchPromptText"; "required": false; "isSignal": true; }; "startSectionTemplate": { "alias": "startSectionTemplate"; "required": false; "isSignal": true; }; "showSearchBtn": { "alias": "showSearchBtn"; "required": false; "isSignal": true; }; "showClearBtn": { "alias": "showClearBtn"; "required": false; "isSignal": true; }; "showFormError": { "alias": "showFormError"; "required": false; "isSignal": true; }; "showValidationMsg": { "alias": "showValidationMsg"; "required": false; "isSignal": true; }; "createBtnRoute": { "alias": "createBtnRoute"; "required": false; "isSignal": true; }; "createBtnNoRoute": { "alias": "createBtnNoRoute"; "required": false; "isSignal": true; }; "createBtnText": { "alias": "createBtnText"; "required": false; "isSignal": true; }; "showAdditionalColumns": { "alias": "showAdditionalColumns"; "required": false; "isSignal": true; }; "smallerFonts": { "alias": "smallerFonts"; "required": false; "isSignal": true; }; "useSelection": { "alias": "useSelection"; "required": false; "isSignal": true; }; "initialQuery": { "alias": "initialQuery"; "required": false; "isSignal": true; }; "createButton": { "alias": "createButton"; "required": false; "isSignal": true; }; "_formSchema": { "alias": "formSchema"; "required": false; }; "searchObservableFunc": { "alias": "searchObservableFunc"; "required": false; "isSignal": true; }; }, { "initialQuery": "initialQueryChange"; "_rowClick": "rowClick"; "clickedExpandRow": "clickedExpandRow"; "clickedCreate": "clickedCreate"; }, never, ["[tablePanel]"], true, never>;
}
/**
 * Interface for search form schema
 * Extends the base form schema with additional properties specific to search functionality
 */
interface ISearchFormSchema<TQuery extends IObjectLiteral = any, TRow extends IObjectLiteral = any> extends IBaseFormSchema<TQuery, FindItemComponent<TQuery, TRow>, {
    [K in keyof TQuery]: AbstractControl<any, any>;
}> {
    /** Whether the field needs an action button */
    needsButton?: boolean;
    /** Whether the field is standalone (not part of the main search) */
    standalone?: boolean;
    /** Whether the field should always be visible in compact mode */
    nonCompact?: boolean;
    /** Action to perform when the field's button is clicked */
    action?: (row: TRow, cell: any, form?: FormGroup<IStrictFormGroup<TQuery>>) => any;
}

/**
 * A component that displays a watermark image.
 *
 * This component renders a watermark using an image path from the environment configuration.
 * It uses OnPush change detection strategy for better performance.
 *
 * @example
 * <watermark></watermark>
 */
declare class WatermarkComponent {
    /**
     * The path to the watermark image, retrieved from environment configuration.
     */
    readonly imgPath: _angular_core.ModelSignal<string>;
    /**
     * Initializes a new instance of the WatermarkComponent class.
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WatermarkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WatermarkComponent, "watermark", never, { "imgPath": { "alias": "imgPath"; "required": false; "isSignal": true; }; }, { "imgPath": "imgPathChange"; }, never, never, true, never>;
}

declare class ResetRoutingModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResetRoutingModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ResetRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ResetRoutingModule>;
}

declare class ETSResetModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSResetModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ETSResetModule, never, [typeof i1$1.CommonModule, typeof ResetRoutingModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ETSResetModule>;
}

declare class VersionRoutingModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VersionRoutingModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<VersionRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<VersionRoutingModule>;
}

declare class VersionService {
    sS: ETSStorageService;
    readonly currentVersion: string;
    private readonly storageKey;
    readonly logoutTrigger$: Subject<{
        newVersionNumber: string;
        oldVersionNumber: string;
    }>;
    constructor(sS: ETSStorageService);
    checkCurrentVersion(): void;
    getLocalVersion(): string;
    setLocalVersion(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VersionService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<VersionService>;
}

declare class VersionComponent implements OnInit {
    vS: VersionService;
    env: Environment;
    props: ITextCase2[];
    constructor(vS: VersionService);
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VersionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VersionComponent, "version", never, {}, {}, never, never, true, never>;
}

declare class ETSVersionModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSVersionModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ETSVersionModule, never, [typeof i1$1.CommonModule, typeof VersionRoutingModule, typeof SharedModule, typeof VersionComponent], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ETSVersionModule>;
}

declare class TimeoutTesterRoutingModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimeoutTesterRoutingModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TimeoutTesterRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TimeoutTesterRoutingModule>;
}

declare class TimeoutTesterComponent implements OnInit {
    apiS: ApiService;
    iS: InfoDialogService;
    startTime: number;
    endTime: number;
    form: FormGroup<{
        timeout: FormControl<number>;
    }>;
    loading: boolean;
    constructor(apiS: ApiService, iS: InfoDialogService);
    ngOnInit(): void;
    get value(): number;
    get expectedEndTime(): number;
    get elapsedTime(): number;
    submit(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimeoutTesterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimeoutTesterComponent, "timeout-tester", never, {}, {}, never, never, true, never>;
}

declare class ETSTimeoutTesterModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSTimeoutTesterModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ETSTimeoutTesterModule, never, [typeof i1$1.CommonModule, typeof TimeoutTesterRoutingModule, typeof SharedModule, typeof i4$1.MatProgressBarModule, typeof TimeoutTesterComponent], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ETSTimeoutTesterModule>;
}

declare class ExtraPagesRoutingModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtraPagesRoutingModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ExtraPagesRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ExtraPagesRoutingModule>;
}

declare class ETSExtraPagesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ETSExtraPagesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ETSExtraPagesModule, never, [typeof i1$1.CommonModule, typeof ExtraPagesRoutingModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ETSExtraPagesModule>;
}

/**
 * Interface representing a web user in the authentication system.
 * Contains user identification, access credentials, and contact information.
 */
interface IWebUser {
    /** Unique identifier for the user */
    id: number;
    /** Agent number associated with the user */
    agentNo: string;
    /** Client number associated with the user */
    clientNo: string;
    /** Access level or permissions for the user */
    access: string;
    /** Provider number associated with the user */
    providerNo: string;
    /** User's full name */
    fullName: string;
    /** Username for authentication */
    username: string;
    /** Company code the user belongs to */
    companyCode: string;
    /** Identifier of who created this user account */
    createdBy: string;
    /** User's password */
    password: string;
    /** URL where the user should log in */
    loginUrl: string;
    /** User's email address */
    email: string;
    /** Authentication token for the user */
    token: string;
    /** User's phone number */
    phoneNumber: string;
}

/**
 * Service for handling web user authentication operations.
 * Provides methods for login, logout, password management, and user data storage.
 */
declare class WebUserAuthenticationService {
    /** Key used for storing user data in local storage */
    readonly userKey = "webUser";
    /** Counter for tracking authentication attempts */
    count: number;
    /** Maximum number of authentication attempts allowed */
    readonly maxCount = 5;
    /** Type of access for the current user */
    accessType: string;
    /** Base URL for API endpoints */
    baseURL: string;
    /** API service for making HTTP requests */
    protected apiS: ApiService;
    /** Storage service for managing local data */
    protected sS: ETSStorageService;
    /**
     * Initializes the service and retrieves user data from local storage
     */
    constructor();
    /**
     * Sends a forgot password request to initiate password reset process
     * @param data Object containing username and URLs for login and password authentication
     * @returns Observable of the API response
     */
    forgetPassword(data: {
        username: string;
        loginUrl: string;
        passwordAuthUrl: string;
    }): rxjs.Observable<any>;
    /**
     * Authenticates a user with username and password
     * @param username User's username or email
     * @param password User's password
     * @returns Observable of the authenticated user data
     * @throws Error if user does not have access to the platform
     */
    loginUser(username: string, password: string): rxjs.Observable<IWebUser>;
    /**
     * Logs out the current user by clearing storage and redirecting to home
     */
    logout(): void;
    /**
     * Saves user data to local storage
     * @param user User data to be saved
     */
    saveToLocal(user: IWebUser): void;
    /**
     * Retrieves user data from local storage
     * @returns Promise resolving to the stored user data
     */
    getFromLocal(): Promise<any>;
    /**
     * Updates a user's password using a reference code (typically from email)
     * @param data Object containing user credentials and reference code
     * @returns Observable of the API response with updated username
     */
    updatePasswordWithReference(data: {
        emailOrUsername: string;
        password: string;
        confirmPassword: string;
        reference: string;
    }): rxjs.Observable<{
        userName: string;
    }>;
    /**
     * Validates a password reset reference code sent via email
     * @param reference The reference code to validate
     * @returns Observable of the validation response containing user details
     */
    validateReference(reference: string): rxjs.Observable<{
        id: number;
        email: string;
        username?: string;
        reference: string;
        passwordAuthUrl: string;
        loginUrl?: any;
        createdOn: string;
        expireOn: string;
        verified?: any;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WebUserAuthenticationService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WebUserAuthenticationService>;
}

/**
 * Creates a route guard that checks if a user is authenticated.
 *
 * This function returns a guard that verifies user authentication by checking
 * if a user exists in local storage. If no user is found, it redirects to the
 * specified authentication route.
 *
 * @param type - The type of WebUserAuthenticationService to inject
 * @param authRoute - The route to redirect to if authentication fails (defaults to '/auth')
 * @returns A CanActivateChildFn that resolves to true if authenticated, false otherwise
 */
declare const webUserAuthenticationGuard: (type: Type<WebUserAuthenticationService>, authRoute?: string) => CanActivateChildFn;

/**
 * Creates an HTTP interceptor function for web user authentication.
 *
 * This interceptor adds an Authorization header to outgoing HTTP requests that target
 * the configured API base URL, but only if a valid token is available. It also handles
 * 401 Unauthorized responses by redirecting to the login page.
 *
 * @param config - Configuration object for the interceptor
 * @param config.token - Function that returns the current authentication token
 * @param config.apiBaseUrl - Base URL of the API that requires authentication
 * @returns An Angular HTTP interceptor function
 */
declare const webUserAuthenticationInterceptor: (config: {
    token: () => string;
    apiBaseUrl: string;
}) => HttpInterceptorFn;

/**
 * Component that handles the password recovery process for web users.
 *
 * This component provides a form for users to enter their email address
 * and request a password reset. It sends the request to the authentication
 * service and redirects to the reset password page upon success.
 */
declare class WebUserForgotPasswordComponent {
    route: ActivatedRoute;
    router: Router;
    authS: WebUserAuthenticationService;
    uS: UtilityService;
    /**
     * Form group for the password recovery process.
     * Contains a single control for the user's email address.
     */
    recoverPasswordForm: FormGroup<{
        username: FormControl<string>;
    }>;
    /**
     * Creates an instance of WebUserForgotPasswordComponent.
     *
     * @param route - The activated route service for navigation
     * @param router - The router service for navigation
     * @param authS - The authentication service for password recovery operations
     * @param uS - The utility service for displaying notifications
     */
    constructor(route: ActivatedRoute, router: Router, authS: WebUserAuthenticationService, uS: UtilityService);
    /**
     * Initiates the password recovery process.
     *
     * Sends a request to the authentication service with the user's email address
     * and URLs for login and password update. Upon success, displays a confirmation
     * message and redirects to the reset password page.
     *
     * @returns A promise that resolves when the password recovery process is complete
     */
    recoverPassword(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WebUserForgotPasswordComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WebUserForgotPasswordComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

/**
 * Component that handles web user login functionality.
 * This is a standalone component with no template that manages the login form and authentication process.
 */
declare class WebUserLoginComponent {
    route: ActivatedRoute;
    router: Router;
    authS: WebUserAuthenticationService;
    uS: UtilityService;
    /**
     * Form group containing the login credentials fields.
     * Includes userName and password, both required.
     */
    form: FormGroup<{
        userName: _angular_forms.FormControl<any>;
        password: _angular_forms.FormControl<any>;
    }>;
    /**
     * Stores error message if login fails.
     */
    errMsg: null;
    /**
     * Creates an instance of WebUserLoginComponent.
     * @param route - The activated route for navigation context
     * @param router - The router service for navigation after successful login
     * @param authS - The authentication service for handling login requests
     * @param uS - The utility service for displaying information messages
     */
    constructor(route: ActivatedRoute, router: Router, authS: WebUserAuthenticationService, uS: UtilityService);
    /**
     * Handles the login form submission.
     * Attempts to authenticate the user with the provided credentials.
     * Navigates to home page on success, displays error on failure.
     * Will not attempt login if maximum login attempts have been reached.
     * @returns A promise that resolves when the login process completes
     */
    submit(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WebUserLoginComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WebUserLoginComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

/**
 * Component for handling password reset functionality for web users.
 * Provides a form for users to reset their password using a reference code.
 */
declare class WebUserResetPasswordComponent {
    authS: WebUserAuthenticationService;
    uS: UtilityService;
    route: ActivatedRoute;
    router: Router;
    /** Minimum length requirement for password */
    minLength: number;
    /** Maximum length requirement for password */
    maxLength: number;
    /** Flag indicating if the submit operation is in progress */
    loading: boolean;
    /** Flag indicating if the reference validation operation is in progress */
    loading2: boolean;
    /** Form group containing the password reset form controls */
    form: FormGroup<{
        emailOrUsername: FormControl<any>;
        password: FormControl<any>;
        confirmPassword: FormControl<any>;
        reference: FormControl<any>;
    }>;
    /** Flag indicating if the reference code has been validated */
    validated: boolean;
    /**
     * Creates an instance of WebUserResetPasswordComponent.
     * @param authS - Service for web user authentication operations
     * @param uS - Utility service for common functionality
     * @param route - Service for accessing route parameters
     * @param router - Service for navigation between routes
     */
    constructor(authS: WebUserAuthenticationService, uS: UtilityService, route: ActivatedRoute, router: Router);
    /**
     * Custom validator function to ensure password and confirm password fields match.
     * @param form - The form group containing the password fields
     * @returns A CustomValidationError object if validation fails, null otherwise
     */
    ValidateConfirmPassword(form: FormGroup): CustomValidationError;
    /**
     * Validates the reference code provided by the user.
     * If valid, populates the form with user information retrieved from the server.
     */
    validateReference(): Promise<void>;
    /**
     * Submits the password reset form.
     * If successful, updates the user's password, logs them in, and redirects to home page.
     */
    submit(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WebUserResetPasswordComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WebUserResetPasswordComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

export { AddItemComponent, ApiService, AppRouteBase, AppRouteService, AppRouteState, AppService, ArraySplitter, AuthenticationInterceptorService, AutocompleteComponent, AutocompleteModule, AutocompleteService, AutocompleteTdRfComponent, BaseFormGenerator, BaseNativeEventListenerDirective, BlinkingBlocksComponent, BouncingBallComponent, Btn, BtnComponent, BtnLg, BtnLgComponent, BtnLinkComponent, BtnModule, BtnService, ButtonComponent, CETSInput, CacheService, CacheUpdaterService, CardComponent, CardComponent as CardModule, CodeTitleDescPipe, CommafyNumberDirective, ButtonComponent as ComponentsModule, Config, ConfirmDialogComponent, ConfirmDialogComponent as ConfirmDialogModule, Constant, CustomDatePipe, DEFAULT_TIMEOUT, DateInputComponent, Day, DayHourMinInputComponent, DebouncerService, DesktopClassDirective, DetailsBtnComponent, DetailsBtnComponent as DetailsBtnModule, DirectivesModule, DocumentsNameDisplayComponent, DocumentsNameDisplayComponent as DocumentsNameDisplayModule, DragDropFileUploadDirective, EETSPageBtnID, ELanguage, EMenuLocation, EMenuType, EPageType, ESubSystem, ESystem, ESystemBusLine, ETSCheckForUpdateService, ETSConfirmDialogService, ETSExtraPagesModule, ETSFKVP, ETSForms, ETSHandleUnrecoverableStateService, ETSKVP, ETSLogUpdateService, ETSLoggerModule, ETSMenuItem, ETSMenuItemDivider, ETSPageNotFoundComponent, ETSPromptUpdateService, ETSReactiveFormInputService, ETSResetModule, ETSResponsivenessDirectiveModule, ETSRobotModule, ETSServiceWorkerService, ETSStorageService, ETSThemeService, ETSTimeoutTesterModule, ETSVersionModule, ETSWindowSecurityService, EUA, EVFunctions, EValidationType, EditableTextCaseComponent, EditableTextCaseComponent as EditableTextCaseModule, SDKEnvironment as Environment, EqualChildrenDirective, ErrorMessagePipe, ErrorReporterService, ExportTableComponent, ExportTableComponent as ExportTableModule, FCInput, FadingBarsComponent, FadingCirclesComponent, FieldToLabelPipe, FieldsToDisplayComponent, FileUploadComponent, FilterArrayByStringPipe, FilterArrayPipe, FilterFormArrayControlPipe, FilterFormArrayGroupPipe, FilterOptions, FindItemComponent, FormErrorComponent, FormGeneratedValueComponent, FormGeneratorComponent, FormGeneratorComponent as FormGeneratorModule, FormGeneratorService, FormInvalidClassDirective, FormInvalidClassPipe, FormLinkComponent, FormLinkComponent as FormLinkModule, FormSchemaToTableColumnsPipe, FormTabHeadersComponent, FormTabHeadersComponent as FormTabHeadersModule, FormValuePipe, FunctionCaller, FunctionCaller1, FunctionCaller2, FunctionCaller3, GenderPipe, GetColFormattedEPipe, GetColFormattedPipe, GetHeadersPipe, GetRawFieldsPipe, GetValueLabel, GlobalErrorHandlerService, HasFormValuePipe, HasValuePipe, HideDesktopDirective, HideMobileDirective, HtmlerService, HttpListCaller, HttpListCaller1, HttpListCaller2, IdlerComponent, IdlerService, ImageLoaderDirective, ImageUpload, IndexCompLayoutComponent, InfoDialogComponent, InfoDialogModule, InfoDialogService, InfoIconComponent, InfoIconComponent as InfoIconModule, InputBasicComponent, InputClassPipe, InputComponent, InputComponents, InputControlComponent, InputFormatDirective, InputFormatService, InputLabelComponent, InputModule, InputNGModelComponent, InputNGModelComponent as InputNGModelModule, InputPipesModule, InputService, InputTD_RFComponent, InputTableComponent, InputTableService, IntegerOnlyDirective, IsClonePage, IsShowPage, LabelComponent, LabelComponent as LabelModule, Lbl, ListOptionFinderPipe, LoaderComponent, LoaderComponent as LoaderModule, LoaderService, LocalCacheService, Log, LoggerComponent, LoggerInterceptorService, LoggerRoutingModule, LoggerService, MHrefDirective, MobileClassDirective, ModalBodyDirective, ModalComponent, ModalComponents, ModalFooterDirective, ModalFormComponent, ModalFormComponent as ModalFormModule, ModalHeaderComponent, ModalHeaderComponent as ModalHeaderModule, ModalComponent as ModalModule, MouseClickListenerDirective, MouseEnterListenerDirective, MouseLeaveListenerDirective, MrouterLinkirective, NELEventName, NarrationHistoryCompComponent, NativeEventListenerDirectives, NegativeNumberOnlyDirective, NumberFormatService, NumberPipe, ObjectToArrayPipe, ObjectToLabelsPipe, OnClickDirective, OptionLabeller, OptionerPipe, OptionsFormatter, PSDirective, PageCenterBodyComponent, PageLoader, PageLoaderService, PageModal, PageService, PageTemplateComponent, PageTemplateComponent as PageTemplateModule, PageToComponentComponent, PageToComponentDirective, PageToComponentComponent as PageToComponentModule, PageToComponentService, PaginatorComponent, PaginatorPipe, PhoneNumberComponent, PhoneNumberService, PointerMoveListenerDirective, prototypes_d as Prototypes, RefresherPipe, RemoveUsedOptionsPipe, RemoveUsedOptionsReactivePipe, ReplaceAllPipe, RequestLoggerInterceptorService, RequestTimeoutInterceptorService, ResizeGridPipe, ResponsiveValPipe, ResponsivenessDirective, ReverseTranslateSingleNLPipe, RichTextEditorComponent, RichTextEditorRFComponent, RingRipplesComponent, RoundPipe, RouteItem, RowActionsComponent, RowActionsComponent as RowActionsModule, BaseEffect as SDKBaseEffect, BaseFacadeService as SDKBaseFacadeService, BaseService as SDKBaseService, SDKTranslateNoLoaderPipe, SDKTranslatePipe, SDKTranslateSingleNoLoaderPipe, SDKTranslateSinglePipe, SaverClass, SaverService, SecondsToTimePipe, SharedModule, SortPipe, SpinnerComponent, StorageClass, StrConcatenatorPipe, SvgIconComponent, SvgIconService, TableBaseComponent, TableCol, TableContextPipe, TableHttpsComponent, TableInputClassFunctionPipe, TableInputComponent, TableInputRowComponent, TablePipesModule, TablePlainComponent, TableService, TableToStringPipe, TextAreaModalComponent, TextAreaModalService, TextCase1Component, TextCase2Component, TextCase2ForObject, TextCaseInputComponent, TextCaseService, TextComponent, ToAnyArrayPipe, ToAnyPipe, ToggleInputFormComponent, TranslatePipeModule, TranslationService, TranslatorCaseComponent, TranslatorDirective, TrimPipe, TrimTextPipe, TyperPipe, UserActivity, UserActivityService, UtilityPipesModule, UtilityService, ValidationMessageComponent, ValidationMessageNgmodelComponent, ValidationMsg, Validator, ValueFormatterPipe, ValueOrXPipe, VersionService, VerticalNavComponent, ViewFormButtonsComponent, ViewFormButtonsComponent as ViewFormButtonsModule, WatermarkComponent, WebUserAuthenticationService, WebUserForgotPasswordComponent, WebUserLoginComponent, WebUserResetPasswordComponent, WebcamMediaComponent, XOrYPipe, YearMonthTdRfComponent, _SharedModule, configForms, configPatterns, configValidationMessages, environment, pageErrorRouter, webUserAuthenticationGuard, webUserAuthenticationInterceptor, widthOffsetPipe };
export type { BtnGroup, BtnType, CellType, CustomValidationError, ETimeType, IAPIConfig, IAutoCompleteOption, IBaseFormSchema, IBtn, ICode, ICodeDescription, ICodeTitle, IConfigImages, ICountry, IDocMetadata, IETSMenuItem, IETSMenuItemBase, IETSMenuItemRaw, IETSMenuItemRawBase, IFile_Metadata, IFindItemShownFields, IFormGeneratorConfig, IFormOptions, IFormSchema, IFormSchema2, IGetQuery, IInfoDialogBtn, IInputConfig, IInputTableScheme, IKVP, ILbl, ILog, IMktDescription, IObjectLiteral, IOption, IPageErrorConfig, IPageState, IResponse, IRowOption, ISearchFormSchema, ISearchResponse, ISearchResponse2, IServiceFunction, IStrictFormGroup, ISystem, ITab, ITableCol, ITableInputBtn, ITableInputFormSchema, ITableName, ITableSearchFunc, ITableSearchResp, ITextCase2, IToggleOption, IToggleRow, ITranslatorConfig, ITypeDescription, IUADeletionPayload, IUASearchObj, IUASearchResponse, IUploadSubmissionResp, IUserActivity, IValidationMessage, IValidationResp, IValueLabel, IWebUser, IWebcamMedia, IconType, ImageType, InputSubType, InputType, KeyOfType, NELEvent, NELEventHandler, NELMouseEventHandler, NELPointerEventHandler, NELQuery, OptionLabelType, RefCat, SVGIconType, SortType, Status, SubCategory, TypeOf, ValueType };