import * as i1$1 from '@angular/router';
import { ActivatedRoute, Router, NavigationExtras, QueryParamsHandling, Route, Routes } from '@angular/router';
import { WebSocketSubject } from 'rxjs/webSocket';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject, ReplaySubject, Subscription, Subject } from 'rxjs';
import * as _angular_forms from '@angular/forms';
import { FormControl, AbstractControl, UntypedFormArray, FormArray, FormGroup, ValidatorFn, AbstractControlOptions, AsyncValidatorFn } from '@angular/forms';
import * as _angular_core from '@angular/core';
import { ErrorHandler, InjectionToken, PipeTransform, QueryList, ElementRef, DestroyRef, EventEmitter, OnInit, TemplateRef, Type, ChangeDetectorRef, Signal, ApplicationRef, SimpleChanges, OutputRefSubscription } from '@angular/core';
import { HttpClient, HttpErrorResponse, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpHeaders } from '@angular/common/http';
import { Title, DomSanitizer } from '@angular/platform-browser';
import { SwUpdate } from '@angular/service-worker';
import * as _serene_dev_toast_notifications from '@serene-dev/toast-notifications';
import { ToastNotificationsService } from '@serene-dev/toast-notifications';
import * as _angular_material_dialog from '@angular/material/dialog';
import { MatDialog, MatDialogRef, MatDialogConfig } from '@angular/material/dialog';
import * as herlhay_helpers from 'herlhay-helpers';
import { MatSnackBar } from '@angular/material/snack-bar';
import * as i1 from '@angular/common';
import { DatePipe, Location, DecimalPipe, CurrencyPipe, TitleCasePipe, AsyncPipe, KeyValue as KeyValue$1 } from '@angular/common';
import { BreakpointObserver } from '@angular/cdk/layout';
import jfd from 'js-file-download';
import { MatFormFieldAppearance } from '@angular/material/form-field';
import { MatCheckboxChange } from '@angular/material/checkbox';
import * as i11 from '@angular/material/slide-toggle';
import { MatSlideToggleChange } from '@angular/material/slide-toggle';
import * as i7 from '@angular/material/datepicker';
import { MatCalendar } from '@angular/material/datepicker';
import { Socket } from 'socket.io-client';
import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import { MatChipInputEvent } from '@angular/material/chips';
import { SelectionChange, SelectionModel } from '@angular/cdk/collections';
import * as _angular_cdk_overlay from '@angular/cdk/overlay';
import * as _angular_cdk_bidi from '@angular/cdk/bidi';
import * as _angular_cdk_dialog from '@angular/cdk/dialog';
import { MatPaginator } from '@angular/material/paginator';
import { MatTableDataSource, MatTable } from '@angular/material/table';
import { MatSort } from '@angular/material/sort';
import { MatIconRegistry } from '@angular/material/icon';
import * as i8 from '@angular/material/input';
import * as i9 from '@angular/material/core';
import * as i10 from '@angular/material/select';
import * as i12 from '@angular/material/tooltip';
import { MatStepper } from '@angular/material/stepper';

/**
 * Global type declarations for extending built-in JavaScript types
 */
declare global {
    /**
     * Extensions to the String prototype
     */
    interface String {
        /**
         * Removes a specified character from the string
         * @param character - Character to remove (defaults to '/')
         * @returns String with the specified character removed
         * @example
         * ```ts
         * 'hello/world'.stripChar('/') // Returns 'helloworld'
         * ```
         */
        stripChar(character?: string): string;
        /**
         * Removes the last occurrence of a specified character
         * @param character - Character to remove (defaults to '/')
         * @returns String with the last occurrence of the character removed
         * @example
         * ```ts
         * 'hello/world/'.lastStripChar('/') // Returns 'hello/world'
         * ```
         */
        lastStripChar(character?: string): string;
        /**
         * Replaces all occurrences of a character with another string
         * @param character - Character to replace (defaults to '/')
         * @param replacement - String to replace with (defaults to empty string)
         * @returns String with all occurrences replaced
         * @example
         * ```ts
         * 'hello/world'.unChar('/', '-') // Returns 'hello-world'
         * ```
         */
        unChar(character?: string, replacement?: string): string;
        /**
         * Converts Pascal case to Sentence case
         * @returns String in sentence case
         * @example
         * ```ts
         * 'smallBook'.toSentenceCase() // Returns 'Small Book'
         * ```
         */
        toSentenceCase(): string;
        /**
         * Replaces all occurrences of a substring
         * @param character - Substring to replace
         * @param replacement - String to replace with
         * @returns String after replacement
         * @example
         * ```ts
         * 'hello world'.replaceAllSubStr('world', 'universe') // Returns 'hello universe'
         * ```
         */
        replaceAllSubStr(character?: string, replacement?: string): string;
        /**
         * Adds a character to the beginning of the string until it reaches the expected length
         * @param character - Character to add
         * @param expectedLength - Target length of the string
         * @returns Padded string
         * @example
         * ```ts
         * '123'.addPrecedingChar('0', 5) // Returns '00123'
         * ```
         */
        addPrecedingChar(character: string, expectedLength: number): string;
        /**
         * Converts a string to camel case
         * @returns String in camel case
         * @example
         * ```ts
         * 'Hello World'.toCamelCase() // Returns 'helloWorld'
         * ```
         */
        toCamelCase(): string;
        /**
         * Converts a string to title case
         * @returns String in title case
         * @example
         * ```ts
         * 'hello world'.toTitleCase() // Returns 'Hello World'
         * ```
         */
        toTitleCase(): string;
    }
    /**
     * Extensions to the Array prototype
     */
    interface Array<T> {
        /**
         * Merges all elements of the array into a single string
         * @returns Concatenated string
         * @example
         * ```ts
         * ['hello', 'world'].merge() // Returns 'helloworld'
         * ```
         */
        merge(): T;
        /**
         * Gets an element from the array by index from the end
         * @param index - Index from the end (defaults to 0)
         * @returns Element at the specified index from the end
         * @example
         * ```ts
         * ['a','b','c'].reverseIndex(1) // Returns 'b'
         * ```
         */
        reverseIndex(index?: number): T;
        /**
         * Gets the last element of the array
         * @returns Last element
         * @example
         * ```ts
         * ['a','b','c'].lastItem() // Returns 'c'
         * ```
         */
        lastItem(): T;
        /**
         * Randomly shuffles the elements of the array
         * @returns Shuffled array
         * @example
         * ```ts
         * ['a','b','c'].shuffle() // Returns randomly shuffled array
         * ```
         */
        shuffle(): T[];
        /**
         * Sorts array by the length of a specified field
         * @param field - Field to sort by
         * @param reverse - Whether to sort in descending order
         * @returns Sorted array
         * @example
         * ```ts
         * [{name: 'a'}, {name: 'abc'}].sortByFieldLength('name') // Returns [{name: 'a'}, {name: 'abc'}]
         * ```
         */
        sortByFieldLength(field: keyof T, reverse?: boolean): T[];
        /**
         * Sorts array by a specified field
         * @param field - Field to sort by
         * @param isString - Whether the field is a string
         * @param reverse - Whether to sort in descending order
         * @returns Sorted array
         * @example
         * ```ts
         * [{age: 20}, {age: 30}].sort2('age', false) // Returns [{age: 20}, {age: 30}]
         * ```
         */
        sort2(field: keyof T, isString?: boolean, reverse?: boolean): T[];
        /**
         * Sorts array by a specified field with automatic type detection
         * @param field - Field to sort by
         * @param reverse - Whether to sort in descending order
         * @returns Sorted array
         * @example
         * ```ts
         * [{age: 20}, {age: 30}].sort3('age') // Returns [{age: 20}, {age: 30}]
         * ```
         */
        sort3(field: keyof T, reverse?: boolean): T[];
        /**
         * Removes empty items from the array
         * @param expectedFields - Fields to check for emptiness
         * @param config - Configuration options
         * @param config.ignoreBooleanFields - Whether to ignore boolean fields
         * @param config.fieldsType - Whether to check included or excluded fields
         * @returns Array with empty items removed
         * @example
         * ```ts
         * [{name: 'a'}, {name: ''}].removeEmptyItems(['name']) // Returns [{name: 'a'}]
         * ```
         */
        removeEmptyItems(expectedFields?: (keyof T)[], config?: {
            ignoreBooleanFields?: boolean;
            fieldsType?: 'included' | 'excluded';
        }): T[];
        /**
         * Converts array to a map using a key field
         * @param keyField - Field to use as key
         * @returns Map with keyField as keys
         * @example
         * ```ts
         * [{id: 1, name: 'a'}].toMap('id') // Returns {1: {id: 1, name: 'a'}}
         * ```
         */
        toMap(keyField: keyof T): {
            [x: string]: T;
        };
        /**
         * Converts array to a map using a key mapping function
         * @param keyMap - Function to generate keys
         * @returns Map with generated keys
         * @example
         * ```ts
         * [{id: 1}].toMap(item => `key_${item.id}`) // Returns {'key_1': {id: 1}}
         * ```
         */
        toMap(keyMap: (row: T) => string | number): {
            [x: string]: T;
        };
        /**
         * Converts array to a map with value transformation
         * @param keyField - Field to use as key
         * @param valueMap - Function to transform values
         * @returns Map with transformed values
         * @example
         * ```ts
         * [{id: 1, name: 'a'}].toMap('id', item => item.name) // Returns {1: 'a'}
         * ```
         */
        toMap<NT>(keyField: keyof T, valueMap: (item: T) => NT): {
            [x: string]: NT;
        };
        /**
         * Groups array by a field
         * @param keyField - Field to group by
         * @param keyMap - Optional function to transform group keys
         * @returns Object with grouped arrays
         * @example
         * ```ts
         * [{type: 'a', value: 1}, {type: 'a', value: 2}].groupBy('type')
         * // Returns {a: [{type: 'a', value: 1}, {type: 'a', value: 2}]}
         * ```
         */
        groupBy(keyField: keyof T, keyMap?: (value: any) => string): {
            [x: string]: T[];
        };
        /**
         * Converts array to a boolean map
         * @returns Object with array values as keys and true as values
         * @example
         * ```ts
         * ['a', 'b'].toBooleanMap() // Returns {a: true, b: true}
         * ```
         */
        toBooleanMap(): {
            [x: string]: boolean;
        };
    }
    /**
     * Extensions to the Function prototype
     */
    interface Function {
        /**
         * Creates a clone of the function
         * @returns Cloned function
         */
        clone: any;
    }
}
declare module '../components/icon/icon.model' {
    interface IconNames {
    }
}

declare namespace prototypes_d {
  export {
  };
}

/**
 * Type representing all available SVG icons
 * @remarks
 * This type defines all the possible icon names that can be used with the SvgIconService.
 * Each icon name corresponds to an SVG string in the service's registry.
 */
type SVGIconType = 'add' | 'attachment' | 'back-2' | 'back' | 'billing-2' | 'billing' | 'calendar' | 'close' | 'comment' | 'copy' | 'country' | 'dashboard-2' | 'dashboard' | 'delete' | 'dispatch' | 'down-chevron' | 'email' | 'enforcement' | 'error' | 'export' | 'facebook' | 'filter' | 'flag' | 'grid' | 'hashtag' | 'home' | 'image' | 'info' | 'linkedin' | 'list' | 'notification' | 'organisation' | 'password' | 'payment' | 'printer' | 'profile' | 'profiles' | 'reconcilitation' | 'refresh' | 'report' | 'reporting' | 'revenue' | 'search' | 'settings' | 'stacks' | 'street' | 'save' | 'success' | 'telephone' | 'twitter' | 'up' | 'upload' | 'user-card' | 'user' | 'validation';

/**
 * Base interface for menu items containing common properties
 */
interface IMenuItemBase {
    /** Array of breadcrumb items with key-value pairs */
    breadcrumbs?: KeyValue<string, string>[];
    /** String representation of breadcrumbs */
    breadcrumbsStr?: string;
    /** Indicates if the menu item has submenu items */
    hasSub?: boolean;
    /** Icon for the menu item, can be SVG type or string */
    icon?: SVGIconType | string;
    /** Unique identifier for the menu item */
    id?: string | number;
    /** Index position of the menu item */
    index?: number;
    /** Indicates if this is a divider item */
    isDivider?: boolean;
    /** Indicates if this is a parent menu item */
    isP?: boolean;
    /** Display label for the menu item */
    label?: string;
    /** Lowercase version of the label for case-insensitive matching */
    labelLowerCase?: string;
    /** Navigation link for the menu item */
    link?: string;
    /** Action to execute when menu item is clicked */
    action?: () => any;
    /** Query parameters for the navigation link */
    queryParams?: {
        [x: string]: string | number | boolean;
    };
    /** ID of the parent menu item */
    parentID?: string | number;
    /** Position of submenu relative to the menu item */
    submenuPosition?: 'before' | 'after';
    /** System icon identifier */
    systemIcon?: string;
    /** System link identifier */
    systemLink?: string;
    /** Indicates if the menu item is ready to be displayed */
    isReady?: boolean;
}
/**
 * Interface for raw menu item data structure
 */
interface IMenuItemRawBase {
    [x: string]: IMenuItemRaw;
}
/**
 * Interface for raw menu item with nested submenu structure
 */
interface IMenuItemRaw extends IMenuItemBase {
    /** Nested submenu items */
    subs?: {
        [x: string]: IMenuItemRaw;
    };
}
/**
 * Interface for processed menu item with flattened submenu structure
 */
interface IMenuItem extends IMenuItemBase {
    /** Indicates if the user has access to this menu item */
    canAccess?: boolean;
    /** Indicates if the submenu is expanded */
    expanded?: boolean;
    /** Strategy for handling query parameters during navigation */
    queryParamsHandling?: 'merge' | 'preserve' | '';
    /** Array of submenu items */
    subs?: IMenuItem[];
}
/**
 * Class implementing the IMenuItem interface with additional functionality
 */
declare class MenuItem implements IMenuItem {
    /** Array of breadcrumb items */
    breadcrumbs?: KeyValue<string, string>[];
    /** String representation of breadcrumbs */
    breadcrumbsStr?: string;
    /** Indicates if the user has access to this menu item */
    canAccess?: boolean;
    /** Database ID of the menu item */
    dbID: number;
    /** Indicates if the menu item is disabled */
    disabled: boolean;
    /** Indicates if the menu item has buttons */
    hasButtons: boolean;
    /** Indicates if the menu item has submenu items */
    hasSub?: boolean;
    /** Icon for the menu item */
    icon: string;
    /** Unique identifier for the menu item */
    id: string | number;
    /** Index position of the menu item */
    index?: number;
    /** Indicates if this is a divider item */
    isDivider?: boolean;
    /** Indicates if this is a parent menu item */
    isP?: boolean;
    /** Display label for the menu item */
    label: string;
    /** Lowercase version of the label */
    labelLowerCase?: string;
    /** Level of nesting in the menu hierarchy */
    level?: number;
    /** Navigation link for the menu item */
    link: string;
    /** ID of the parent menu item */
    parentID: string | number;
    /** Position of submenu relative to the menu item */
    submenuPosition?: 'before' | 'after';
    /** Array of submenu items */
    subs: MenuItem[];
    /** System icon identifier */
    systemIcon?: string;
    /** System link identifier */
    systemLink?: string;
    /** Indicates if the user has view access */
    viewAccess: boolean;
    /** Indicates if the user has edit access */
    editAccess: boolean;
    /**
     * Getter for edit access
     * @returns boolean indicating edit access
     */
    get _editAccess(): boolean;
    /**
     * Setter for edit access
     * @param value - New edit access value
     */
    set _editAccess(value: boolean);
    /**
     * Getter for view access
     * @returns boolean indicating view access
     */
    get _viewAccess(): boolean;
    /**
     * Setter for view access
     * @param value - New view access value
     */
    set _viewAccess(value: boolean);
    /**
     * Creates a new MenuItem instance
     * @param menuItem - Menu item data
     * @param parent - Parent menu item
     */
    constructor(menuItem: IMenuItem, parent?: IMenuItem);
    /**
     * Toggles the disabled state of the menu item
     */
    toggle(): void;
    /**
     * Toggles the view access state of the menu item
     */
    toggleView(): void;
    /**
     * Toggles the edit access state of the menu item
     */
    toggleCreate(): void;
    /**
     * Allows edit access for all submenu items
     */
    allowEditAllSubMenus(): void;
    /**
     * Disables edit access for all submenu items
     */
    disableEditAllSubMenus(): void;
    /**
     * Allows view access for all submenu items
     */
    allowViewAllSubMenus(): void;
    /**
     * Disables view access for all submenu items
     */
    disableViewAllSubMenus(): void;
    /**
     * Toggles edit access for all submenu items
     */
    toggleEditAllSubMenus(): void;
    /**
     * Toggles view access for all submenu items
     */
    toggleViewAllSubMenus(): void;
    /**
     * Allows both view and edit access for the menu item
     */
    allowAuthorization(): void;
    /**
     * Disables both view and edit access for the menu item
     */
    disableAuthorization(): void;
    /**
     * Toggles both view and edit access for the menu item
     */
    toggleAuthorization(): void;
}
/**
 * Class representing a divider menu item
 */
declare class MenuItemDivider extends MenuItem {
    /**
     * Creates a new MenuItemDivider instance
     */
    constructor();
}
/**
 * Enum representing page button IDs
 */
declare enum EPageBtnID {
    agentCommissions = "PAC8",
    agentCreditNotes = "PACN10",
    agentDocuments = "PAD2",
    agentEndorsements = "PAE3",
    agentLoan = "PAL1",
    agentNotes = "PAN6",
    agentPendingQuotes = "PAPQ11",
    agentPolicies = "PAP7",
    agentProduction = "PAP9",
    agentWebLogIn = "PAWL4",
    agentWorkflows = "PAW5",
    agentCalendar = "PAC6",
    clientCalendar = "PCC11",
    clientDocuments = "PCD12",
    clientEndorsements = "PCE13",
    clientNotes = "PCN14",
    clientOtherBusiness = "PCOB15",
    clientPendingPayments = "PCPP16",
    clientPendingQuotes = "PCPQ17",
    clientPolicies = "PCP18",
    clientRelationships = "PCR19",
    clientUnderwritingEvents = "PCUE20",
    clientWebLogIn = "PCWL21",
    clientWorkflows = "PCW22"
}
/**
 * Generic interface for key-value pairs
 * @template K - Type of the key
 * @template V - Type of the value
 */
interface KeyValue<K, V> {
    /** The key */
    key: K;
    /** The value */
    value: V;
}

/**
 * Class for managing page loading states and providing loading indicators
 */
declare class Loader {
    /**
     * Text to display while loading
     */
    loaderText: string;
    /**
     * Internal array tracking active loaders
     * @private
     */
    private _pageLoaders;
    /**
     * Creates a new Loader instance
     */
    constructor();
    /**
     * Gets whether any loaders are currently active
     * @returns true if there are active loaders, false otherwise
     */
    get isLoading(): boolean;
    /**
     * Starts one or more page loaders
     * @param value - Number of loaders to start (default: 1)
     * @returns The current number of active loaders
     */
    startPl(value?: number): number;
    /**
     * Restarts the loader by clearing all existing loaders and starting a new one
     */
    restartPl(): void;
    /**
     * Stops one or more page loaders
     * @param value - Number of loaders to stop (default: 1)
     * @returns The current number of active loaders
     */
    stopPl(value?: number): number;
    /**
     * Callback function to execute when all loaders have stopped
     */
    onLoaderStopped: (...args: any[]) => any;
    /**
     * Stops all active page loaders
     */
    stopAllPls(): void;
}

/**
 * Base class for environment configuration and management
 * Provides core functionality for application environment settings
 */
declare class EnvironmentClass {
    production: boolean;
    apiBaseUrl?: string;
    /**
     * List of menu items for the application navigation
     */
    menus: IMenuItem[];
    /**
     * Current title of the active page
     */
    pageTitle: string;
    /**
     * Default currency symbol for the application
     * @default '₦'
     */
    currency: string;
    /**
     * Name of the current environment (e.g., 'development', 'staging', 'production')
     */
    readonly name: string;
    /**
     * Storage mechanism to use for persisting data
     * @default 'localStorage'
     */
    storageKey: 'localStorage' | 'sessionStorage';
    /**
     * Name of the application
     */
    appName: string;
    /**
     * Whether authentication is required for the application
     */
    authenticate?: boolean;
    /**
     * Whether debug logging is enabled
     * @default true in non-production environments
     */
    debug?: boolean;
    /**
     * Name of the organization
     */
    organisationName: string;
    /**
     * Storage key for user data
     * @default 'user'
     */
    readonly userStorageKey = "user";
    /**
     * Storage key for embedded user data
     * @default 'enbedded-user'
     */
    readonly enbeddedUserStorageKey = "enbedded-user";
    /**
     * Storage key for super user/admin data
     * @default 'super-user'
     */
    readonly adminUserStorageKey = "super-user";
    /**
     * Page loader instance for managing loading states
     */
    pageLoader: Loader;
    /**
     * API request timeout configuration
     * Can be specified in milliseconds or as a Date object
     * @default One year from current date
     */
    requestTimeout: number | Date;
    /**
     * Current version number of the application
     */
    versionNo: string;
    /**
     * MixPanel analytics token
     */
    mixPanelToken: string;
    /**
     * Currently active subdomain
     */
    activeSubdomainSite: string;
    /**
     * Whether WebSocket connections are enabled
     */
    useWebSocket: boolean;
    /**
     * Whether the current user has super admin privileges
     */
    isSuperAdmin: boolean;
    /**
     * URL for the client admin interface
     */
    clientAdminUrl: any;
    /**
     * Whether API requests should be encrypted
     */
    encryptAPIRequests: boolean;
    /**
     * Whether the application is running in embedded mode
     */
    isEmbedMode: boolean;
    /**
     * Key used for embedded mode authentication
     * @default 'weffwdfuion'
     */
    readonly embedKey = "weffwdfuion";
    /**
     * Configuration for Tawk.io chat widget
     */
    tawkIOConfig: {
        propertyId: string;
        widgetId: string;
    };
    /**
     * User's authentication token
     */
    token: string;
    /**
     * Application domain
     */
    domain?: string;
    /**
     * Sets the loading state of the page
     * @param v - Whether the page is loading
     */
    set loading(v: boolean);
    /**
     * Creates a new EnvironmentClass instance
     * @param production - Whether the environment is in production mode
     * @param name - Name of the environment
     * @param apiBaseUrl - Base URL for API endpoints
     */
    constructor(production: boolean, name: string, apiBaseUrl?: string);
    /**
     * Updates the environment configuration with new values
     * @param env - New environment configuration to apply
     */
    updateEnvironment(env: EnvironmentClass): void;
    /**
     * Checks if the current environment is development
     * @returns true if the environment is development, false otherwise
     */
    get isDev(): boolean;
}

/**
 * Extended environment class that includes routing and WebSocket capabilities
 * @extends EnvironmentClass
 */
declare class Environment extends EnvironmentClass {
    production: boolean;
    apiBaseUrl?: string;
    /**
     * The currently activated route in the Angular application
     */
    activatedRoute: ActivatedRoute;
    /**
     * WebSocket connection for real-time communication
     */
    socket: WebSocketSubject<any>;
    /**
     * Creates a new Environment instance
     * @param production - Whether the environment is in production mode
     * @param name - Name of the environment (e.g., 'development', 'staging', 'production')
     * @param apiBaseUrl - Base URL for API endpoints
     */
    constructor(production: boolean, name: string, apiBaseUrl?: string);
}

/**
 * Environment object
 */
declare const HHenvironment: Environment;

/**
 * Represents the different types of input fields that can be used in forms
 * @remarks
 * This type defines all possible input field types supported by the application.
 * It is used to specify the type of input field when creating form controls.
 */
type InputType = 'autocomplete' | 'button' | 'buttonToggle' | 'checkbox' | 'checkedbox' | 'date' | 'date-range' | 'datetime-local' | 'dhm' | 'email' | 'file' | 'form' | 'formgroup' | 'fileButton' | 'number' | 'password' | 'progress' | 'percentage' | 'radio' | 'select' | 'tel' | 'text' | 'textarea' | 'template' | 'time' | 'toggle' | 'viewer';
/**
 * Interface representing a key-value pair with optional styling
 * @remarks
 * This interface provides a basic structure for key-value pairs with optional CSS class for styling.
 */
interface IKVP {
    /** The key identifier */
    readonly key?: any;
    /** The value associated with the key */
    value?: string | boolean | number;
    /** Optional CSS class for styling */
    cls?: string;
}
/**
 * Class implementing a key-value pair with optional styling
 * @remarks
 * This class provides a concrete implementation of the IKVP interface.
 * It can be used to create key-value pairs with optional styling.
 *
 * @example
 * ```ts
 * const kvp = new KVP('name', 'John Doe', 'highlight');
 * ```
 */
declare class KVP implements IKVP {
    readonly key: string;
    value?: string | boolean | number;
    cls?: string;
    constructor(key: string, value?: string | boolean | number, cls?: string);
}
/**
 * Extended key-value pair with additional functionality for form fields
 * @remarks
 * This class extends KVP to add form-specific functionality like labels, editability,
 * routing, and formatting.
 *
 * @example
 * ```ts
 * const fkvp = new FKVP('email', 'Email Address', true, 'user@example.com', 'email', 'Enter your email');
 * ```
 */
declare class FKVP extends KVP {
    inputType?: InputType;
    /** Display label for the field */
    label: string;
    /** Whether the field is editable */
    editable?: boolean;
    /** Whether the field is currently being edited */
    editing?: boolean;
    /** Optional route for navigation */
    route?: string;
    /** Function to generate route dynamically */
    routeFunc?: (item: any) => Promise<string> | Observable<string>;
    /** Help text or hint for the field */
    hint?: string;
    /** Action to perform on the field */
    action?: any;
    /** Whether the field represents a phone number */
    isPhone?: boolean;
    /** Whether the field represents an email address */
    isEmail?: boolean;
    /** Function to format the field value */
    formatter?: (val: any) => string | Promise<string> | Observable<string>;
    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);
}
/**
 * Interface for labeled key-value pairs with optional hint
 * @remarks
 * This interface extends IKVP to add a hint property for additional information.
 */
interface ILbl extends IKVP {
    /** Additional hint or help text */
    hint?: string;
}
/**
 * Class implementing a labeled key-value pair
 * @remarks
 * This class provides a concrete implementation of the ILbl interface.
 * It can be used to create labeled key-value pairs with optional hints.
 *
 * @example
 * ```ts
 * const lbl = new Lbl('status', 'Active', 'Current status of the item');
 * ```
 */
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 button configuration
 * @remarks
 * This interface defines the structure for button configuration including
 * actions, styling, and state.
 */
interface IBtn<TAction = (...args: any[]) => void> extends IKVP {
    /** Action to perform when button is clicked */
    action?: TAction;
    /** Group the button belongs to */
    group?: BtnGroup;
    /** Help text for the button */
    help?: string;
    /** Link for navigation */
    link?: string;
    /** Icon to display on the button */
    icon?: SVGIconType;
    /** Whether the button is an icon-only button */
    iconBtn?: boolean;
    /** Whether the button is disabled */
    disabled?: boolean;
    /** Whether the button is in loading state */
    loading?: boolean;
    /** Whether to show help icon */
    showHelpIcon?: boolean;
    /** Button label text */
    label?: string;
    /** Button type/style */
    type?: BtnType;
    /** Additional data */
    extra?: any;
}
/**
 * Class implementing button functionality
 * @remarks
 * This class provides a concrete implementation of the IBtn interface.
 * It can be used to create buttons with various configurations.
 *
 * @example
 * ```ts
 * const btn = new Btn('submit', () => console.log('clicked'), 'primary', 'save');
 * ```
 */
declare class Btn implements IBtn {
    cls?: string;
    group?: BtnGroup;
    help?: string;
    link?: string;
    icon?: SVGIconType;
    iconBtn?: boolean;
    readonly action?: (data?: any, ...args: any[]) => void;
    readonly key?: string;
    showHelpIcon?: boolean;
    label?: string;
    route?: string;
    type?: BtnType;
    extra?: any;
    loading?: boolean;
    disabled?: boolean;
    constructor(key: string, action?: (data?: any, ...args: any[]) => any, type?: BtnType, icon?: SVGIconType, cls?: string, help?: string, showHelpIcon?: boolean, loading?: boolean, disabled?: boolean);
}
/**
 * Class implementing large button functionality
 * @remarks
 * This class provides a specialized implementation for large buttons
 * with additional styling and functionality.
 *
 * @example
 * ```ts
 * const btnLg = new BtnLg('download', 'Download File', () => downloadFile());
 * ```
 */
declare class BtnLg implements IBtn {
    readonly key: string;
    value: string | boolean | number;
    readonly action?: () => void;
    cls?: string;
    extra?: any;
    constructor(key: string, value?: string | boolean | number, action?: any, cls?: string, extra?: any);
}
/**
 * Available button types/styles
 * @remarks
 * This type defines all possible button styles supported by the application.
 */
type BtnType = 'clear' | 'clear-pm' | 'close' | 'danger-outline' | 'danger' | 'dark-outline' | 'dark' | 'light' | 'outline-nm' | 'outline' | 'outline-light' | 'primary' | 'secondary' | 'success';
/**
 * Available button groups
 * @remarks
 * This type defines all possible button groups supported by the application.
 */
type BtnGroup = 'add' | 'clone' | 'close' | 'create' | 'delete' | 'download' | 'edit' | 'link' | 'search' | 'show' | 'submit' | 'upload';
/**
 * Available icon types
 * @remarks
 * This type defines all possible icon types supported by the application.
 */
type IconType = 'access' | 'add' | 'adjust' | 'calendar' | 'cash' | 'checked' | 'checklist' | 'clone' | 'close' | 'cogs' | 'delete' | 'download' | 'edit' | 'export' | 'file' | 'filter' | 'generate' | 'guard' | 'history' | 'home' | 'import' | 'info' | 'link' | 'lock' | 'next' | 'pen' | 'post' | 'previous' | 'renew' | 'save' | 'search' | 'show' | 'snooze' | 'unlock' | 'upload' | 'view' | 'users' | 'recycle' | 'truck' | 'tag' | 'receipt' | 'bank' | 'arrowh';
/**
 * Interface for code-title pairs
 * @remarks
 * This interface defines a structure for pairs of codes and their corresponding titles.
 */
interface ICodeTitle {
    /** The code identifier */
    code: string;
    /** The title text */
    title: string;
}
/**
 * Interface for code-description pairs
 * @remarks
 * This interface defines a structure for pairs of codes and their corresponding descriptions.
 */
interface ICodeDescription {
    /** The code identifier */
    code: string;
    /** The description text */
    description: string;
}
/**
 * Interface for market event descriptions
 * @remarks
 * This interface defines a structure for market event codes and their descriptions.
 */
interface IMktDescription {
    /** The market event code */
    mktEventCode: string;
    /** The description text */
    description: string;
}
/**
 * Interface for code-only objects
 * @remarks
 * This interface defines a structure for objects that only contain a code identifier.
 */
interface ICode {
    /** The code identifier */
    code: string;
}
/**
 * Enum for menu locations
 * @remarks
 * This enum defines the possible locations for menus in the application.
 */
declare enum EMenuLocation {
    viewPage1 = "viewPage"
}
/**
 * Enum for days of the week
 * @remarks
 * This enum defines the days of the week with their full names.
 */
declare enum Day {
    sunday = "Sunday",
    monday = "Monday",
    tuesday = "Tuesday",
    wednesday = "Wednesday",
    thursday = "Thursday",
    friday = "Friday",
    saturday = "Saturday"
}
/**
 * Enum for page types
 * @remarks
 * This enum defines the different types of pages supported by the application.
 */
declare enum EPageType {
    clonePage = "Clone",
    editPage = "Edit",
    viewPage = "View",
    createPage = "Create",
    indexPage = "Index"
}
/**
 * Enum for supported languages
 * @remarks
 * This enum defines the languages supported by the application.
 */
declare enum ELanguage {
    EN = "EN",
    FR = "FR"
}
/**
 * Enum for validation types
 * @remarks
 * This enum defines the different types of validation supported by the application.
 */
declare enum EValidationType {
    email = "email",
    entityNumber = "entityNumber",
    maxlength = "maxlength",
    minlength = "minlength",
    mobile = "mobile",
    name = "name",
    normal = "normal",
    passwordNotMatch = "passwordNotMatch",
    pattern = "pattern",
    required = "required",
    unique = "unique",
    custom = "custom"
}
/**
 * Interface for validation messages
 * @remarks
 * This interface defines the structure for validation messages.
 */
interface IValidationMessage {
    /** The type of validation */
    type: EValidationType;
    /** The validation message text */
    message: string;
}
/**
 * Interface for sort configuration
 * @remarks
 * This interface defines the structure for sort configuration in data tables.
 */
interface Sort {
    /** Whether the data is sorted */
    sorted: boolean;
    /** Whether the data is unsorted */
    unsorted: boolean;
    /** Whether the data is empty */
    empty: boolean;
}
/**
 * Interface for paginated data
 * @remarks
 * This interface defines the structure for paginated data responses.
 */
interface IPage<T> {
    /** The content items */
    content: T[];
    /** Current page number */
    number: number;
    /** Number of items per page */
    size: number;
    /** Total number of elements */
    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 configuration */
    sort: Sort;
    /** Number of elements in current page */
    numberOfElements: number;
    /** Whether the page is empty */
    empty: boolean;
}
/**
 * Interface for search query parameters
 * @remarks
 * This interface defines the structure for search query parameters.
 */
interface ISearchQuery {
    /**
     * Page number (starts at 1)
     */
    page?: number;
    /** Number of items per page */
    limit?: number;
    /** Search term */
    search?: string;
    /** Additional search parameters */
    [x: string]: string | number | boolean;
}
/**
 * Interface for search response
 * @remarks
 * This interface defines the structure for search responses.
 */
interface ISearchResponse<T = any> {
    /** Paginated data */
    page: IPage<T>;
    /** Total size of the list */
    listSize: number;
    /** Current page number */
    pageNumber?: number;
    /** Number of items per page */
    pageSize?: number;
    /** Search criteria used */
    searchCriteria: any;
}
/**
 * Alternative interface for search response
 * @remarks
 * This interface provides an alternative structure for search responses.
 */
interface ISearchResponse2<T = any> {
    /** The content items */
    content: T[];
    /** Whether the response is empty */
    empty: boolean;
    /** Whether this is the first page */
    first: boolean;
    /** Whether this is the last page */
    last: boolean;
    /** Current page number */
    number: number;
    /** Number of elements in current page */
    numberOfElements: number;
    /** Number of items per page */
    size: number;
    /** Total number of elements */
    totalElements: number;
    /** Total number of pages */
    totalPages: number;
    /** Sort configuration */
    sort: {
        sorted: boolean;
        unsorted: boolean;
        empty: boolean;
    };
}
/**
 * Type for image categories
 * @remarks
 * This type defines the categories of images supported by the application.
 */
type ImageType = 'pp' | 'other';
/**
 * Interface for tab configuration
 * @remarks
 * This interface defines the structure for tab configuration in the application.
 */
interface ITab {
    /** Tab identifier */
    id?: string;
    /** Target element ID */
    target?: string;
    /** Tab label */
    label: string;
    /** Associated form ID */
    form?: string;
    /** Function to execute on POST */
    postFunction?: (data: any, productCode?: string) => Observable<{
        data: any;
        productCode: string;
    }>;
    /** Function to execute on PUT */
    putFunction?: (data: any, productCode: string) => Observable<{
        data: any;
        productCode: string;
    }>;
    /** Tab data */
    data?: any;
}
/**
 * Interface for custom validation errors
 * @remarks
 * This interface defines the structure for custom validation errors.
 */
interface CustomValidationError {
    /** Custom error message */
    custom?: string;
    /** Maximum length exceeded */
    maxlength?: boolean;
    /** Maximum length exceeded (alternative) */
    maxLength?: boolean;
    /** Minimum length not met */
    minlength?: boolean;
    /** Minimum length not met (alternative) */
    minLength?: boolean;
    /** Item not found */
    notFound?: boolean;
    /** Value not unique */
    notUnique?: boolean;
    /** Pattern mismatch */
    pattern?: boolean;
    /** Required field missing */
    required?: boolean;
    /** Value already in use */
    used?: boolean;
}
/**
 * Enum for menu types
 * @remarks
 * This enum defines the different types of menus supported by the application.
 */
declare enum EMenuType {
    horizontal = "H",
    vertical = "V"
}
/**
 * Interface for value-label pairs
 * @remarks
 * This interface defines a structure for pairs of values and their corresponding labels.
 */
interface IValueLabel<T = string> {
    /** The value */
    value: T;
    /** The display label */
    label: string;
}
/**
 * Interface for image configuration
 * @remarks
 * This interface defines the structure for image configuration in the application.
 */
interface IConfigImages {
    /** Favicon image path */
    favicon: string;
    /** Watermark image path */
    watermark: string;
    /** Logo configuration */
    logo: {
        /** Dark theme logo path */
        dark: string;
        /** Light theme logo path */
        light: string;
    };
    /** Profile picture configuration */
    pp: {
        /** Source image path */
        src: string;
        /** Minimum size image path */
        min: string;
    };
    /** Other images configuration */
    other: {
        /** Source image path */
        src: string;
        /** Minimum size image path */
        min: string;
    };
}
/**
 * Base class for constants
 * @remarks
 * This class serves as a base for defining application constants.
 */
declare class Constant {
}
/**
 * Interface for table names
 * @remarks
 * This interface defines the structure for database table names.
 */
interface ITableName {
    /** Database schema name */
    schema: string;
    /** Primary table name */
    primaryTable: string;
}
/**
 * Interface for state information
 * @remarks
 * This interface defines the structure for state information with an alias.
 */
interface IState extends IListValue<number> {
    /** State alias */
    alias: string;
}
/**
 * Interface for list values
 * @remarks
 * This interface defines a generic structure for list values with optional ID and value.
 */
interface IListValue<TID = string, TValue = any> {
    /** Display name */
    name: string;
    /** Associated value */
    value?: TValue;
    /** Unique identifier */
    id?: TID;
}
/**
 * Enum for time periods
 * @remarks
 * This enum defines the different time periods supported by the application.
 */
declare enum EPeriod {
    daily = "daily",
    weekly = "weekly",
    monthly = "monthly",
    annually = "annually",
    yearly = "yearly",
    today = "today",
    week = "week",
    month = "month",
    year = "year",
    annual = "annual"
}
/**
 * Type for making all properties of T nullable
 * @remarks
 * This type utility makes all properties of a type T nullable.
 */
type PartialNull<T> = {
    [P in keyof T]: T[P] | null;
};
/**
 * Type for strict form group with typed controls
 * @remarks
 * This type utility creates a form group with strictly typed controls.
 */
type IStrictFormGroup<T> = {
    [x in keyof T]: FormControl<T[x]>;
};
/**
 * Interface for objects with string keys and any values
 * @remarks
 * This interface defines a structure for objects with string keys and any type of values.
 */
interface IObjectLiteral {
    [x: string]: any;
}
/**
 * Utility type that extracts keys from T where the value is of type TExpectedFieldType
 * @template T Source object type
 * @template TExpectedFieldType Expected type of the field values to include
 * @remarks
 * This type utility filters object properties to only those matching a specific type.
 * It's useful for type-safe property access and filtering object keys based on their value types.
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 *   email: string;
 *   isActive: boolean;
 * }
 *
 * // Will only include 'name' and 'email' keys
 * type StringFields = KeyOfType<User, string>;
 *
 * // Will only include 'age' key
 * type NumberFields = KeyOfType<User, number>;
 * ```
 */
type KeyOfType<T, TExpectedFieldType> = keyof {
    [P in keyof T as T[P] extends TExpectedFieldType ? P : never]: any;
};

/**
 * Configuration class containing various static configuration values and constants
 */
declare class Config {
    /** Path to the light theme logo */
    static logoLightPath: string;
    /** Path to the dark theme logo */
    static logoDarkPath: string;
    /** Array of optioner values mapping numbers to letters */
    static Optioner: {
        num: number;
        letter: string;
    }[];
    /** Array of month information including ID, short name, ISO string, and long name */
    static Months: {
        id: number;
        short: string;
        isoStr: string;
        long: string;
    }[];
    /** Map of short month names to their full information */
    static ShortMonthsMap: {
        [x: string]: {
            id: number;
            short: string;
            isoStr: string;
            long: string;
        };
    };
    /** Array of boolean options with labels */
    static readonly boolList: IValueLabel<boolean>[];
    /** Array of days with their indices */
    static Days: {
        index: number;
        day: Day;
    }[];
    /** Array of numbers with their ordinal labels */
    static Numbers: {
        num: number;
        label: string;
    }[];
    /** Array of sex options */
    static sexes: string[];
    /** Currency symbol */
    static Currency: string;
    /** Milliseconds in a day */
    static TimeStampDay: number;
    /** Milliseconds in a week */
    static TimeStampWeek: number;
    /** Path to placeholder image */
    static placeholderImage: string;
    /** Array of period options */
    static periods: IListValue<EPeriod>[];
    /** Array of period options including annual */
    static periodsWithAnnual: IListValue<EPeriod>[];
    /** Array of period adverbs */
    static periodAdverbs: IListValue<EPeriod>[];
    /** Placeholder for organization name */
    static organisationPlaceholder: string;
    /** Info email address */
    static infoMail: string;
    /** Sales email address */
    static salesMail: string;
    /** Support email address */
    static supportMail: string;
    /** Support URL */
    static supportURL: string;
    /** Base route for authentication */
    static authBaseRoute: string;
    /** Application name */
    static appName: string;
    /** Array of Nigerian states with their ISO codes and names */
    static states: {
        isoCode: string;
        name: string;
    }[];
}

/**
 * Configuration object containing validation messages for different field types
 */
declare const configValidationMessages: {
    /**
     * Array of common validation messages for normal fields
     */
    normal: ({
        type: string;
        message: string;
    } | {
        type: string;
        message?: undefined;
    })[];
    /**
     * Array of validation messages for address fields
     */
    address: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for local government area fields
     */
    addressLGA: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for class name fields
     */
    className: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for class section fields
     */
    classSection: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for email fields
     */
    email: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for entity number fields
     */
    entityNumber: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for first name fields
     */
    firstname: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for last name fields
     */
    lastname: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for local government area fields
     */
    lga: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for maiden name fields
     */
    maidenName: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for mobile number fields
     */
    mobile: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for name fields
     */
    name: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for numeric fields
     */
    numbers: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for occupation fields
     */
    occupation: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for other name fields
     */
    othername: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for password fields
     */
    password: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for pattern validation fields
     */
    pattern: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for required fields
     */
    required: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for sex fields
     */
    sex: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for subject name fields
     */
    subjectName: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for unique fields
     */
    unique: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for username fields
     */
    username: {
        type: string;
        message: string;
    }[];
    /**
     * Array of validation messages for URL fields
     */
    url: {
        type: string;
        message: string;
    }[];
};

/**
 * Service for handling encryption and decryption operations using AES
 * Provides methods for encrypting and decrypting text and objects
 */
declare class EncryptorClass {
    /** Default AES key for encryption/decryption */
    RESPONSE_AESKEY: string;
    /** Secret key used for encryption/decryption */
    secret: string;
    /** Delimiter used for handling special characters in encrypted text */
    plusDelimiter: string;
    /**
     * Encryption Decryption service
     */
    constructor();
    /**
     * Encrypts text data using AES encryption
     * @param data - The data to encrypt
     * @param key - Optional encryption key (defaults to secret)
     * @returns Encrypted text string
     */
    encryptText: (data: any, key?: string) => string;
    /**
     * Decrypts encrypted text using AES decryption
     * @param data - The encrypted text to decrypt
     * @param key - Optional decryption key (defaults to secret)
     * @returns Decrypted data
     */
    decryptText: (data: string, key?: string) => any;
    /**
     * Encrypts an item using AES encryption
     * @param data - The item to encrypt
     * @returns Encrypted string
     * @throws Error if AES key is not set
     */
    encryptItem: (data: any) => string;
    /**
     * Decrypts an encrypted item using AES decryption
     * @param data - The encrypted string to decrypt
     * @typeParam T - The expected type of the decrypted data
     * @returns Decrypted data of type T
     * @throws Error if AES key is not set
     */
    decryptItem: <T = any>(data: string) => T;
}

/**
 * Service for handling data encryption and decryption operations
 * Extends EncryptorClass to provide AES encryption functionality
 * @Injectable Provided in root
 * @see EncryptorClass
 * @example
 * ```typescript
 * // Encrypt data
 * const encrypted = encryptorService.encrypt('sensitive data');
 *
 * // Decrypt data
 * const decrypted = encryptorService.decrypt(encrypted);
 *
 * // Encrypt object
 * const encryptedObj = encryptorService.encryptObject({
 *   username: 'john',
 *   password: 'secret'
 * });
 *
 * // Decrypt object
 * const decryptedObj = encryptorService.decryptObject(encryptedObj);
 * ```
 */
declare class EncryptorService extends EncryptorClass {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EncryptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EncryptorService>;
}

/**
 * Abstract base class for implementing caching functionality
 * Provides basic cache operations like get, set, and check existence
 */
declare abstract class CacheClass {
    /** Internal cache storage */
    protected _cache: {
        [x: string]: any;
    };
    constructor();
    /**
     * Gets the current cache state
     * @returns The current cache object
     */
    get cache(): {
        [x: string]: any;
    };
    /**
     * Checks if a key exists in the cache
     * @param key - The key to check
     * @returns true if the key exists, false otherwise
     */
    has: (key: string) => boolean;
    /**
     * Retrieves an item from the cache
     * @param key - The key of the item to retrieve
     * @typeParam T - The expected type of the retrieved item
     * @returns The cached item or undefined if not found
     */
    getItem: <T>(key: string) => T;
    /**
     * Sets an item in the cache
     * @param key - The key to store the item under
     * @param data - The data to store
     * @typeParam T - The type of data being stored
     */
    setItem<T>(key: string, data: T): void;
    /**
     * Gets an item from the cache and optionally sets a new value
     * @param key - The key to retrieve or set
     * @param newValue - Optional new value to set if the key doesn't exist
     * @typeParam T - The type of data being retrieved or set
     * @returns An Observable that emits the current or new value
     */
    getAndSet<T>(key: string, newValue?: T | Promise<T>): Observable<T>;
}

/**
 * Service for managing in-memory caching operations
 * Extends CacheClass to provide caching functionality
 * @Injectable Provided in root
 * @see CacheClass
 * @example
 * ```typescript
 * // Store data in cache
 * cacheService.set('userData', { id: 1, name: 'John' });
 *
 * // Retrieve data from cache
 * const userData = cacheService.get('userData');
 *
 * // Remove data from cache
 * cacheService.remove('userData');
 *
 * // Clear all cached data
 * cacheService.clear();
 *
 * // Check if key exists in cache
 * const exists = cacheService.has('userData');
 * ```
 */
declare class CacheService extends CacheClass {
    /**
     * Creates a new instance of CacheService
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CacheService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CacheService>;
}

/**
 * Configuration interface for custom storage operations
 */
interface IStorageConfig {
    /**
     * Asynchronous function to save data to storage
     * @param key - The key to store the data under
     * @param data - The data to be stored
     * @returns Promise that resolves when the data is saved
     */
    saveAsyncFunc?: <T>(key: string, data: T) => Promise<any>;
    /**
     * Asynchronous function to retrieve data from storage
     * @param key - The key to retrieve data from
     * @returns Promise that resolves with the retrieved data
     */
    getAsyncFunc?: <T>(key: string) => Promise<T>;
    /**
     * Asynchronous function to remove data from storage
     * @param key - The key of the data to remove
     * @returns Promise that resolves when the data is removed
     */
    removeAsyncFunc: (key: string) => Promise<any>;
    /**
     * Asynchronous function to clear all data from storage
     * @returns Promise that resolves when storage is cleared
     */
    clearAsyncFunc: () => Promise<any>;
    /**
     * Synchronous function to save data to storage
     * @param key - The key to store the data under
     * @param data - The data to be stored
     * @returns The saved data
     */
    saveFunc?: <T>(key: string, data: T) => any;
    /**
     * Synchronous function to retrieve data from storage
     * @param key - The key to retrieve data from
     * @returns The retrieved data
     */
    getFunc?: <T>(key: string) => T;
}
/**
 * A class that provides storage functionality with encryption support
 *
 * @example
 * ```typescript
 * const storage = new StorageClass(encryptor, true, 'localStorage');
 * storage.setup({
 *   saveAsyncFunc: async (key, data) => {   },
 *   getAsyncFunc: async (key) => {   }
 * });
 *
 * // Save data
 * storage.saveItem('user', { name: 'John' });
 *
 * // Get data
 * const user = storage.getItem('user');
 * ```
 */
declare class StorageClass {
    protected eS: EncryptorClass;
    /**
     * Specify whether it is a production environment
     */
    readonly isProduction: boolean;
    /**
     * name of local storage location
     */
    readonly storageKey: 'localStorage' | 'sessionStorage';
    /**
     * Custom configuration for storage operations
     */
    protected customConfig: IStorageConfig;
    /**
     * Creates a new instance of StorageClass
     * @param eS - Instance of EncryptorClass for data encryption/decryption
     * @param isProduction - Whether the environment is production
     * @param storageKey - The type of storage to use ('localStorage' or 'sessionStorage')
     */
    constructor(eS: EncryptorClass, 
    /**
     * Specify whether it is a production environment
     */
    isProduction: boolean, 
    /**
     * name of local storage location
     */
    storageKey?: 'localStorage' | 'sessionStorage');
    /**
     * Sets up custom configuration for storage operations
     * @param config - The configuration object
     */
    setup(config: IStorageConfig): void;
    /**
     * Encrypts an item
     * @param data - The data to encrypt
     * @returns The encrypted data
     */
    encrypt: (data: any) => string;
    /**
     * Decrypts an encrypted item
     * @param data - The encrypted data to decrypt
     * @returns The decrypted data
     */
    decrypt: <T = any>(data: string) => T;
    /**
     * Saves an item to the app storage
     * @param key - The key to store the data under
     * @param data - The data to be stored
     * @returns The saved data
     * @throws Error if storage quota is exceeded or other storage errors occur
     */
    saveItem: <T>(key: string, data: T) => any;
    /**
     * Saves an item to the app storage asynchronously
     * @param key - The key to store the data under
     * @param data - The data to be stored
     * @returns Promise that resolves with the saved data
     */
    saveItemA: <T>(key: string, data: T) => Promise<any>;
    /**
     * Get an item from the app storage
     * @param key - The key to retrieve data from
     * @param shouldThrow - Whether to throw an error if the item is not found
     * @returns The retrieved data or null if not found
     * @throws Error if shouldThrow is true and item is not found
     */
    getItem: <T = any>(key: string, shouldThrow?: boolean) => T;
    /**
     * Get an item from the app storage asynchronously
     * @param key - The key to retrieve data from
     * @param shouldThrow - Whether to throw an error if the item is not found
     * @returns Promise that resolves with the retrieved data
     * @throws Error if shouldThrow is true and item is not found
     */
    getItemA: <T = any>(key: string, shouldThrow?: boolean) => Promise<T>;
    /**
     * Remove an item from the app storage
     * @param key - The key of the data to remove
     */
    removeItem: (key: string) => void;
    /**
     * Clear all data from the app storage
     * @returns Promise that resolves when storage is cleared
     */
    clear: () => void | Promise<any>;
}

/**
 * Service for managing browser storage operations
 * Extends StorageClass to provide encrypted storage functionality
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Store data in localStorage
 * storageService.set('userData', { id: 1, name: 'John' });
 *
 * // Retrieve data from localStorage
 * const userData = storageService.get('userData');
 *
 * // Store data in sessionStorage
 * storageService.setSession('tempData', { token: 'abc123' });
 *
 * // Retrieve data from sessionStorage
 * const tempData = storageService.getSession('tempData');
 *
 * // Remove data from storage
 * storageService.remove('userData');
 *
 * // Clear all stored data
 * storageService.clear();
 * ```
 */
declare class StorageService extends StorageClass {
    eS: EncryptorService;
    /**
     * Creates a new instance of StorageService
     * @param eS - EncryptorService instance for data encryption/decryption
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StorageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StorageService>;
}

/**
 * A class that extends CacheClass to provide local storage caching functionality
 * with automatic cache invalidation and persistence.
 */
declare class LocalCacheClass extends CacheClass {
    sS: StorageClass;
    /** Key used to store the cache in local storage */
    protected readonly cacheKey = "cacheKey";
    /** Key used to store the cache creation date in local storage */
    protected readonly cacheCreatedDateKey = "cacheCreatedDateKey";
    /** Number of days the cache remains valid */
    protected readonly validityDays = 7;
    /** Number of milliseconds in one day */
    protected readonly oneDayTimestamp = 86400000;
    /**
     * Creates a new instance of LocalCacheClass
     * @param sS - StorageClass instance for handling local storage operations
     */
    constructor(sS: StorageClass);
    /**
     * Saves the current cache state to local storage
     */
    saveToLocal(): void;
    /**
     * Sets an item in the cache and persists it to local storage
     * @param key - The key to store the data under
     * @param data - The data to store
     * @typeParam T - The type of data being stored
     */
    setItem<T>(key: string, data: T): void;
    /**
     * Gets an item from the cache and optionally sets a new value
     * @param key - The key to retrieve or set
     * @param addFunc - Optional function or value to set if the key doesn't exist
     * @typeParam T - The type of data being retrieved or set
     * @returns An Observable that emits the current or new value
     */
    getAndSet<T>(key: string, addFunc?: T | Promise<T>): rxjs.Observable<T>;
}

/**
 * Service for managing local cache operations using browser storage
 * Extends LocalCacheClass to provide persistent caching functionality
 * Provides methods for storing, retrieving, and managing cached data
 * @Injectable Provided in root
 * @see LocalCacheClass
 * @example
 * ```typescript
 * // Store data in cache
 * localCacheService.set('userData', { id: 1, name: 'John' });
 *
 * // Retrieve data from cache
 * const userData = localCacheService.get('userData');
 *
 * // Remove data from cache
 * localCacheService.remove('userData');
 *
 * // Clear all cached data
 * localCacheService.clear();
 * ```
 */
declare class LocalCacheService extends LocalCacheClass {
    sS: StorageService;
    /**
     * Creates a new instance of LocalCacheService
     * @param sS - StorageService instance for persistent storage operations
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocalCacheService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LocalCacheService>;
}

/**
 * Service for handling HTTP API requests with encryption, caching, and error handling
 * Provides methods for making HTTP requests (GET, POST, PUT, DELETE, PATCH) with built-in encryption,
 * caching, and error handling capabilities. Supports file uploads with progress tracking.
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Make a GET request
 * apiService.get('/users').subscribe(users => {
 *   console.log(users);
 * });
 *
 * // Make a POST request with encryption
 * apiService.post('/users', { name: 'John' }).subscribe(response => {
 *   console.log(response);
 * });
 *
 * // Upload a file with progress tracking
 * apiService.postWithProgress('/upload', { file: myFile }).subscribe({
 *   next: ({ progress, uploaded }) => {
 *     console.log(`Upload progress: ${progress}%`);
 *     if (uploaded) console.log('Upload complete');
 *   }
 * });
 * ```
 */
declare class ApiService {
    eS: EncryptorService;
    http: HttpClient;
    cacheS: CacheService;
    lCacheS: LocalCacheService;
    /**
     * Base URL for API requests
     * @returns The base URL from environment configuration
     */
    protected get baseURL(): string;
    /**
     * Debug flag for logging routes
     */
    protected showRoutes: number;
    /**
     * Default HTTP headers for JSON requests
     * @returns Object containing Content-Type header
     */
    protected get headers(): {
        'Content-Type': string;
    };
    /**
     * HTTP headers for file upload requests
     * @returns Object containing enctype header for multipart/form-data
     */
    protected get fileHeaders(): {
        enctype: string;
    };
    /**
     * Number of retry attempts for failed requests
     */
    protected retryCount: number;
    /**
     * Encrypts data for API requests if encryption is enabled
     * @param obj - Data to encrypt
     * @returns Encrypted data object or original object if encryption is disabled
     * @example
     * ```typescript
     * const encrypted = apiService.encrypt({ name: 'John' });
     * // Returns: { data: 'encrypted_string' } if encryption is enabled
     * // Returns: { name: 'John' } if encryption is disabled
     * ```
     */
    encrypt: (obj: any) => any;
    /**
     * Decrypts API response data if encryption is enabled
     * @param obj - Encrypted response object
     * @returns Decrypted data or original object if encryption is disabled
     * @throws Error if decryption fails
     * @example
     * ```typescript
     * const decrypted = apiService.decrypt({ data: 'encrypted_string', status: 'success' });
     * // Returns decrypted object if successful
     * // Throws error if status is 'error'
     * ```
     */
    decrypt: (obj: {
        data: string;
        status: "success" | "error";
    }) => any;
    /**
     * Logs route information for debugging purposes
     * @param method - HTTP method used
     * @param route - API route
     * @param extras - Additional parameters
     */
    private logRoutes;
    /**
     * Handles API response formatting
     * @param response - API response
     * @param extras - Additional options for response handling
     * @returns Formatted response
     */
    handleResponse(response: any, extras: IExtras): any;
    /**
     * Handles API request errors
     * @param extras - Additional options for error handling
     * @returns Error handler function
     */
    handleRequestError: (extras: IExtras) => (err: HttpErrorResponse) => Observable<never>;
    /**
     * Makes a PATCH request to the API
     * @param route - API endpoint
     * @param body - Request body
     * @param extras - Additional options for the request
     * @returns Observable of the response
     * @example
     * ```typescript
     * apiService.patch('/users/1', { name: 'John' }).subscribe(response => {
     *   console.log(response);
     * });
     * ```
     */
    patch<T = any>(route: string, body?: object | null, extras?: IExtras): Observable<T>;
    /**
     * Makes a PATCH request with file upload
     * @param route - API endpoint
     * @param body - FormData containing files
     * @returns Observable of the response
     */
    patchFile<T = any>(route: string, body: FormData): Observable<T>;
    /**
     * Makes a POST request to the API
     * @param route - API endpoint
     * @param body - Request body
     * @param extras - Additional options for the request
     * @returns Observable of the response
     * @example
     * ```typescript
     * apiService.post('/users', { name: 'John' }).subscribe(response => {
     *   console.log(response);
     * });
     * ```
     */
    post<T = any>(route: string, body?: object | null, extras?: IExtras): Observable<T>;
    /**
     * Makes a POST request with file upload and progress tracking
     * @param route - API endpoint
     * @param body - Object containing files and other data
     * @returns Observable with upload progress and response
     * @example
     * ```typescript
     * apiService.postWithProgress('/upload', { file: myFile }).subscribe({
     *   next: ({ progress, uploaded, body }) => {
     *     console.log(`Progress: ${progress}%`);
     *     if (uploaded) console.log('Upload complete', body);
     *   }
     * });
     * ```
     */
    postWithProgress<T = any>(route: string, body?: {
        [x: string]: File | any;
    } | null | FormData): Observable<{
        body?: T;
        progress?: number;
        uploaded?: boolean;
    }>;
    /**
     * Makes a POST request with file upload
     * @param route - API endpoint
     * @param body - FormData containing files
     * @returns Observable of the response
     */
    postFile<T = any>(route: string, body: FormData): Observable<T>;
    /**
     * Makes a POST request with plain text content
     * @param route - API endpoint
     * @param body - Request body
     * @returns Observable of the response as string
     */
    postString(route: string, body?: any): Observable<string>;
    /**
     * Makes a GET request to the API
     * @param route - API endpoint
     * @param parameters - Query parameters
     * @param extras - Additional options for the request
     * @returns Observable of the response
     * @example
     * ```typescript
     * apiService.get('/users', { page: 1, limit: 10 }).subscribe(users => {
     *   console.log(users);
     * });
     * ```
     */
    get: <T = any>(route: string, parameters?: object | null, extras?: IExtras) => Observable<T>;
    /**
     * Makes a GET request expecting text response
     * @param route - API endpoint
     * @param parameters - Query parameters
     * @returns Observable of the response as string
     */
    getText: <T = string>(route: string, parameters?: Object) => Observable<T>;
    /**
     * Makes a GET request expecting file response
     * @param route - API endpoint
     * @param parameters - Query parameters
     * @returns Observable of the response as ArrayBuffer
     */
    getFile: <T = string>(route: string, parameters?: Object) => Observable<T>;
    /**
     * Makes a GET request with body
     * @param route - API endpoint
     * @param body - Request body
     * @param extras - Additional options for the request
     * @returns Observable of the response
     */
    getWithBody: <T = any>(route: string, body?: any | null, extras?: IExtras) => Observable<T>;
    /**
     * Makes a GET request with local cache
     * @param route - API endpoint
     * @param parameters - Query parameters
     * @param extras - Additional options for the request
     * @returns Observable of the response
     */
    getFromlocal: <T = any>(route: string, parameters?: object | null, extras?: IExtras) => Observable<T>;
    /**
     * Makes a GET request with memory cache
     * @param route - API endpoint
     * @param parameters - Query parameters
     * @param extras - Additional options for the request
     * @returns Observable of the response
     */
    getFromMemory: <T = any>(route: string, parameters?: object | null, extras?: IExtras) => Observable<T>;
    /**
     * Makes a GET request with local cache and automatic refresh
     * @param route - API endpoint
     * @param parameters - Query parameters
     * @param extras - Additional options for the request
     * @returns Observable of the response
     */
    getWithLocalCache: <T = any>(route: string, parameters?: object | null, extras?: IExtras) => Observable<T>;
    /**
     * Parses query parameters into URL string
     * @param parameters - Query parameters
     * @returns URL query string
     */
    getRequestParse(parameters?: Object): string;
    /**
     * Fetches all paginated data from an endpoint
     * @param route - API endpoint
     * @param query - Query parameters including limit
     * @param dataFieldName - Field name containing the data in response
     * @param extras - Additional options for the request
     * @returns Observable of combined data from all pages
     * @example
     * ```typescript
     * apiService.getAll('/users', { limit: 10 }, 'users').subscribe(allUsers => {
     *   console.log(allUsers); // Contains all users from all pages
     * });
     * ```
     */
    getAll: <T = any>(route: string, query: {
        limit: number;
        [x: string]: any;
    }, dataFieldName: string, extras?: IExtras) => Observable<T[]>;
    /**
     * Makes a PUT request to the API
     * @param route - API endpoint
     * @param body - Request body
     * @param extras - Additional options for the request
     * @returns Observable of the response
     * @example
     * ```typescript
     * apiService.put('/users/1', { name: 'John' }).subscribe(response => {
     *   console.log(response);
     * });
     * ```
     */
    put<T = any>(route: string, body?: object | null, extras?: IExtras): Observable<T>;
    /**
     * Makes a PUT request with file upload
     * @param route - API endpoint
     * @param body - FormData containing files
     * @param extras - Additional options for the request
     * @returns Observable of the response
     */
    putFile<T = any>(route: string, body: FormData, extras?: IExtras): Observable<T>;
    /**
     * Makes a DELETE request to the API
     * @param route - API endpoint
     * @param extras - Additional options for the request
     * @returns Observable of the response
     * @example
     * ```typescript
     * apiService.delete('/users/1').subscribe(response => {
     *   console.log(response);
     * });
     * ```
     */
    delete: <T = any>(route: string, extras?: IExtras) => Observable<any>;
    /**
     * Makes a DELETE request with body
     * @param route - API endpoint
     * @param body - Request body
     * @param extras - Additional options for the request
     * @returns Observable of the response
     */
    deleteWithBody: <T = any>(route: string, body?: any | null, extras?: IExtras) => Observable<any>;
    /**
     * Makes a DELETE request expecting text response
     * @param route - API endpoint
     * @returns Observable of the response as string
     */
    deleteText: (route: string) => Observable<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ApiService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ApiService>;
}
/**
 * Interface for additional request options
 */
interface IExtras {
    /** Whether to skip response formatting */
    noFormat?: boolean;
    /** Whether to skip request encryption */
    dontEncrypt?: boolean;
    /** Whether to skip response decryption */
    dontDecryptResponse?: boolean;
    /** Additional HTTP options */
    options?: any;
    /** Request type for special handling */
    requestType?: 'queryParams';
    /** Whether to skip response formatting */
    dontFormatResponse?: boolean;
    /** Field to pick from response */
    fieldToPickAsResponse?: string;
}
/**
 * Interface for API response
 */
interface IResponse {
    /** Response message */
    message: string;
    /** Response data */
    result: any;
    /** Response status */
    status: 'success' | 'error' | 'failure';
    /** Response status code */
    statusCode: 'SM000' | 'SM001' | 'SM002' | 'SM003';
}
/**
 * Type alias for API extra options
 */
type IAPIExtra = IExtras;

/**
 * Base class for application state management
 * Handles menu state, loading states, and page title management
 */
declare class AppClass {
    /** Array of top-level menu items */
    topMenu: IMenuItem[];
    /** Currently selected top menu item */
    protected _currentTopMenu: MenuItem;
    /** Current page name */
    protected _pageName: string;
    /**
     * Gets the currently selected top menu item
     * @returns The current MenuItem
     */
    get currentTopMenu(): MenuItem;
    /**
     * Sets the currently selected top menu item
     * @param value - The MenuItem to set as current
     */
    set currentTopMenu(value: MenuItem);
    /** Observable for fullscreen mode state */
    setFullscreenMode: BehaviorSubject<boolean>;
    /** Observable for application loading state */
    appLoading: BehaviorSubject<boolean>;
    /**
     * Creates a new instance of AppClass
     * @param menus - Array of top-level menu items
     */
    constructor(menus: IMenuItem[]);
    /**
     * Starts the application loader
     */
    startAppLoader(): void;
    /**
     * Stops the application loader
     */
    stopAppLoader(): void;
    /**
     * Sets default class properties
     */
    setDefaultClass(): void;
    /**
     * Gets the current page name
     * @returns The current page name
     */
    get pageName(): string;
    /**
     * Sets the current page name and updates the title
     * @param value - The new page name
     */
    set pageName(value: string);
    /**
     * Callback function for adding page title
     * @param title - The title to add
     */
    addTitle: (title: any) => void;
}

/**
 * Core application service that handles app-wide functionality
 * Extends AppClass to provide menu and title management
 * @Injectable Provided in root
 * @see AppClass
 * @example
 * ```typescript
 * // Set page title
 * appService.addTitle('Dashboard');
 *
 * // Access menus
 * const menus = appService.menus;
 *
 * // Access environment
 * const appName = appService.environment.appName;
 * ```
 */
declare class AppService extends AppClass {
    titleS: Title;
    apiS: ApiService;
    sS: StorageService;
    /**
     * Creates a new instance of AppService
     * @param titleS - Angular Title service for managing document title
     * @param apiS - Service for making API calls
     * @param sS - Service for managing storage operations
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AppService>;
}

/**
 * Service for managing and determining page types in the application
 * Provides utilities to check the current page type against various page types
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Check if current page is an edit page
 * const isEditPage = pageService.isEdit(activatedRoute);
 *
 * // Check if current page is a create page with override
 * const isCreatePage = pageService.isCreate(activatedRoute, EPageType.createPage);
 * ```
 */
declare class PageService {
    /**
     * Current page type
     * @type {EPageType}
     */
    pageType: EPageType;
    /**
     * Creates a new instance of PageService
     */
    constructor();
    /**
     * Compares the current page type with a preferred page type
     * @param activatedRoute - Current activated route
     * @param overridePageType - Optional page type to override route data
     * @param preferredPageType - Page type to compare against
     * @returns true if the page types match, false otherwise
     * @example
     * ```typescript
     * // Compare page types
     * const isMatchingType = pageService.comparer(
     *   activatedRoute,
     *   EPageType.editPage,
     *   EPageType.editPage
     * );
     * ```
     */
    comparer: (activatedRoute: ActivatedRoute, overridePageType?: EPageType, preferredPageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a clone page
     * @param activatedRoute - Current activated route
     * @param overridePageType - Optional page type to override route data
     * @returns true if the page is a clone page, false otherwise
     * @example
     * ```typescript
     * // Check if current page is a clone page
     * const isClonePage = pageService.isClone(activatedRoute);
     * ```
     */
    isClone: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a create page
     * @param activatedRoute - Current activated route
     * @param overridePageType - Optional page type to override route data
     * @returns true if the page is a create page, false otherwise
     * @example
     * ```typescript
     * // Check if current page is a create page
     * const isCreatePage = pageService.isCreate(activatedRoute);
     * ```
     */
    isCreate: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is an edit page
     * @param activatedRoute - Current activated route
     * @param overridePageType - Optional page type to override route data
     * @returns true if the page is an edit page, false otherwise
     * @example
     * ```typescript
     * // Check if current page is an edit page
     * const isEditPage = pageService.isEdit(activatedRoute);
     * ```
     */
    isEdit: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is an index page
     * @param activatedRoute - Current activated route
     * @param overridePageType - Optional page type to override route data
     * @returns true if the page is an index page, false otherwise
     * @example
     * ```typescript
     * // Check if current page is an index page
     * const isIndexPage = pageService.isIndex(activatedRoute);
     * ```
     */
    isIndex: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a view/show page
     * @param activatedRoute - Current activated route
     * @param overridePageType - Optional page type to override route data
     * @returns true if the page is a view page, false otherwise
     * @example
     * ```typescript
     * // Check if current page is a view page
     * const isViewPage = pageService.isShow(activatedRoute);
     * ```
     */
    isShow: (activatedRoute: ActivatedRoute, overridePageType?: EPageType) => boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageService>;
}

/**
 * HTTP interceptor that handles authentication for API requests
 * Adds authentication token to requests and handles 401 unauthorized responses
 * @implements HttpInterceptor
 * @Injectable Provided in root
 */
declare class AuthenticationInterceptorService implements HttpInterceptor {
    router: Router;
    /**
     * Intercepts HTTP requests to add authentication token and handle unauthorized responses
     * Only adds token to requests targeting the API base URL
     * @param req - The intercepted request
     * @param next - The next handler in the chain
     * @returns Observable of the HTTP event
     * @example
     * ```typescript
     * // The interceptor will automatically add the token to requests
     * // targeting the API base URL
     * this.http.get(`${environment.apiBaseUrl}/users`).subscribe();
     * ```
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    /**
     * Static handler for 401 unauthorized responses
     * Clears local and session storage when called
     * @param e - The HTTP error event
     * @param req - The original request that caused the error
     * @example
     * ```typescript
     * // Subscribe to handle 401 responses
     * on401Response.subscribe(({error, request}) => {
     *   AuthenticationInterceptorService.on401Func(error, request);
     * });
     * ```
     */
    static on401Func: (e: HttpEvent<any>, req: HttpRequest<any>) => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthenticationInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthenticationInterceptorService>;
}
/**
 * BehaviorSubject that emits when a request receives a 401 unauthorized response
 * Emits an object containing the error event and the original request
 * @type {BehaviorSubject<{error: HttpEvent<any>, request: HttpRequest<any>}>}
 * @example
 * ```typescript
 * // Subscribe to handle 401 responses
 * on401Response.subscribe(({error, request}) => {
 *   // Handle unauthorized response
 *   console.log('Unauthorized request:', request.url);
 * });
 * ```
 */
declare const on401Response: BehaviorSubject<{
    error: HttpEvent<any>;
    request: HttpRequest<any>;
}>;

/**
 * Global error handler service for the application
 * Extends Angular's ErrorHandler to provide custom error handling
 * @Injectable Provided in root
 */
declare class GlobalErrorHandlerService extends ErrorHandler {
    /**
     * Creates a new instance of GlobalErrorHandlerService
     */
    constructor();
    /**
     * Handles application-wide errors with custom logic
     * - Reloads the page on chunk loading failures
     * - Ignores ExpressionChangedAfterItHasBeenCheckedError
     * - Delegates other errors to the default error handler
     * @param error - The error to handle
     * @override
     */
    handleError(error: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GlobalErrorHandlerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GlobalErrorHandlerService>;
}

/**
 * Service for handling Mixpanel analytics integration
 * Provides methods for initializing Mixpanel and tracking events
 */
declare class MixPanelService {
    /** Mixpanel API token */
    protected readonly token: string;
    /** User identifier for Mixpanel tracking */
    identifier: string;
    /**
     * Creates a new instance of MixPanelService
     * Initializes Mixpanel if in production environment and token is available
     */
    constructor();
    /**
     * Initializes Mixpanel with the configured token and user identifier
     * @returns void
     */
    init(): void;
    /**
     * Tracks an event in Mixpanel
     * @param actionName - The name of the action to track
     * @param config - Optional configuration object containing status and action details
     * @param config.status - The status of the action (0 for failed, 1 for successful)
     * @param config.action - Additional action properties to track
     * @returns void
     */
    track(actionName: string, config?: {
        status?: 0 | 1;
        action?: any;
    }): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MixPanelService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MixPanelService>;
}

/**
 * Service for handling multi-tenant subdomain routing and access control
 * Provides functionality to determine active subdomain and manage access permissions
 */
declare class MultiTenantInterceptorService {
    router: Router;
    /** Currently active subdomain site */
    activeSubdomainSite: string;
    /** List of whitelisted subdomains that have special access */
    whiteList: string[];
    /**
     * Determines and returns the active subdomain site
     * @returns The active subdomain site name or null if no subdomain is active
     */
    getActiveSite: () => string;
    /**
     * Checks if the current subdomain is a client admin subdomain
     * @returns true if the current subdomain is a client admin subdomain, false otherwise
     */
    isClientAdminSubdomain: () => boolean;
    /**
     * Determines if the current user can view the general site
     * Redirects to dashboard if access is not allowed
     * @returns true if access is allowed, false otherwise
     */
    canViewGeneralSite: () => boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiTenantInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MultiTenantInterceptorService>;
}

/**
 * A utility class for converting numbers to their word representations.
 * This class provides functionality to convert numeric values into their English word equivalents.
 */
declare class NumberToWordsClass {
    /** Function to convert a value to a number */
    num: (x: any) => number;
    /** Function to check if an array is empty */
    isEmpty: (xs: any) => boolean;
    /** Function to negate a boolean value */
    not: (x: any) => boolean;
    /** Function to split an array into chunks of specified size */
    chunk: (n: any) => (xs: any) => any[];
    /** Function to compose two functions */
    comp: (f: any) => (g: any) => (x: any) => any;
    /** Function to reverse an array */
    reverse: (xs: any) => any;
    /** Function to convert a value to an array */
    arr: (x: any) => unknown[];
    /**
     * Creates a new instance of NumberToWordsClass
     */
    constructor();
    /**
     * Transforms a numeric value into its word representation
     * @param value - The numeric value to transform
     * @returns The word representation of the number, or the original value if not a valid integer
     * @example
     * transform(123) // returns "one hundred twenty-three"
     * transform(42) // returns "forty-two"
     */
    transform(value: any): string;
    /**
     * Checks if a value is an integer
     * @param x - The value to check
     * @returns true if the value is an integer, false otherwise
     * @example
     * isInteger(42) // returns true
     * isInteger(42.5) // returns false
     */
    isInteger: (x: any) => boolean;
    /**
     * Converts a number to its word representation
     * @param n - The number to convert
     * @returns The word representation of the number
     * @example
     * numToWords(123) // returns "one hundred twenty-three"
     * numToWords(1000000) // returns "one million"
     */
    numToWords: (n: any) => any;
}
/**
 * An Angular service that provides number to words conversion functionality.
 * This service extends the NumberToWordsClass to provide dependency injection support.
 * @example
 * // In a component:
 * constructor(private numberToWords: NumberToWordsService) {}
 *
 * // Usage:
 * this.numberToWords.transform(42); // returns "forty-two"
 */
declare class NumberToWordsService extends NumberToWordsClass {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberToWordsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NumberToWordsService>;
}

/**
 * HTTP interceptor that manages loading state during HTTP requests
 * Automatically shows and hides a loader for each HTTP request
 * @implements HttpInterceptor
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // The interceptor will automatically:
 * // 1. Show loader when request starts
 * // 2. Hide loader when request completes successfully
 * // 3. Hide loader when request fails
 *
 * // In app.module.ts
 * providers: [
 *   { provide: HTTP_INTERCEPTORS, useClass: RequestLoggerInterceptorService, multi: true }
 * ]
 * ```
 */
declare class RequestLoggerInterceptorService implements HttpInterceptor {
    /**
     * Creates a new instance of RequestLoggerInterceptorService
     */
    constructor();
    /**
     * Intercepts HTTP requests to manage loading state
     * Shows loader when request starts and hides it when request completes or errors
     * @param req - The intercepted request
     * @param next - The next handler in the chain
     * @returns Observable of the HTTP event
     * @example
     * ```typescript
     * // The interceptor will automatically handle loading states:
     * this.http.get('/api/data').subscribe(
     *   response => {
     *     // Loader will be hidden automatically
     *   },
     *   error => {
     *     // Loader will be hidden automatically
     *   }
     * );
     * ```
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequestLoggerInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RequestLoggerInterceptorService>;
}

/**
 * Injection token for configuring the default timeout duration for HTTP requests
 * @type {InjectionToken<number>}
 * @example
 * ```typescript
 * // In app.module.ts
 * providers: [
 *   { provide: DEFAULT_TIMEOUT, useValue: 30000 } // 30 seconds
 * ]
 * ```
 */
declare const DEFAULT_TIMEOUT: InjectionToken<number>;
/**
 * HTTP interceptor that adds timeout functionality to HTTP requests
 * Allows timeout configuration via request headers, environment settings, or default value
 * @implements HttpInterceptor
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Configure timeout in HTTP request
 * this.http.get('/api/data', {
 *   headers: new HttpHeaders().set('timeout', '5000') // 5 seconds
 * });
 * ```
 */
declare class RequestTimeoutInterceptorService {
    protected defaultTimeout: number;
    /**
     * Intercepts HTTP requests to add timeout functionality
     * Timeout duration is determined in the following order:
     * 1. Request header 'timeout'
     * 2. Environment configuration
     * 3. Default timeout value
     * @param req - The intercepted request
     * @param next - The next handler in the chain
     * @returns Observable of the HTTP event with timeout
     * @example
     * ```typescript
     * // The interceptor will automatically apply timeouts:
     * // 1. From request headers
     * this.http.get('/api/data', {
     *   headers: new HttpHeaders().set('timeout', '5000')
     * });
     *
     * // 2. From environment configuration
     * // environment.requestTimeout = 10000;
     *
     * // 3. From default timeout value
     * // providers: [{ provide: DEFAULT_TIMEOUT, useValue: 30000 }]
     * ```
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RequestTimeoutInterceptorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RequestTimeoutInterceptorService>;
}

/**
 * Service for handling confirmation dialogs
 * @remarks
 * This service provides methods to open confirmation dialogs and handle user responses.
 * It uses the ConfirmDialogComponent to display the dialog and returns a Promise
 * that resolves to true when the user confirms and false when they cancel.
 *
 * @example
 * ```typescript
 * constructor(private confirmDialog: ConfirmDialogService) {}
 *
 * async deleteItem() {
 *   const confirmed = await this.confirmDialog.confirm('Are you sure you want to delete this item?');
 *   if (confirmed) {
 *     // Delete the item
 *   }
 * }
 * ```
 */
declare class ConfirmDialogService {
    dialog: MatDialog;
    /**
     * Opens a confirmation dialog with the specified text
     * @param text - The text to display in the dialog
     * @returns A Promise that resolves to true when the user confirms and false when they cancel
     */
    confirm(text: string): Promise<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialogService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ConfirmDialogService>;
}

/**
 * A utility class that provides various helper methods for common operations
 * including file handling, data manipulation, date formatting, and more.
 */
declare class UtilityClass {
    environment: EnvironmentClass;
    /** File download utility */
    downloader: typeof jfd;
    /** Configuration object */
    config: typeof Config;
    /** Validation type enum */
    eValidationType: typeof EValidationType;
    /** Period enum */
    ePeriod: typeof EPeriod;
    /**
     * Creates an instance of UtilityClass
     * @param environment - The environment configuration
     */
    constructor(environment: EnvironmentClass);
    /** Map of supported image MIME types */
    imageTypes: {
        [type: string]: boolean;
    };
    /**
     * Uses a web worker to perform a task asynchronously
     * @param worker - Web worker object
     * @param inputData - Data being passed into web worker
     * @param conditions - Optional conditions for handling worker responses
     * @returns Observable that emits the worker response
     * @example
     * ```typescript
     * const worker = new Worker(new URL('./upload-csv.worker', import.meta.url));
     * utility.useWebWorker(worker, data, {
     *   stop: (res) => res.complete,
     *   error: (res) => res.error
     * });
     * ```
     */
    useWebWorker<T = any>(worker: Worker, inputData: any, conditions?: {
        stop: (res: any) => boolean;
        error: (res: any) => boolean;
    }): Observable<T>;
    /**
     * Converts an array to a key-value pair object
     * @param arr - Array to be converted
     * @param keyField - The field to be used as the key
     * @param map - Optional mapping function to transform array items
     * @returns Object with keyField values as keys and array items as values
     * @example
     * ```typescript
     * const users = [{id: 1, name: 'John'}, {id: 2, name: 'Jane'}];
     * const userMap = utility.arrayToMap(users, 'id');
     * // Result: {1: {id: 1, name: 'John'}, 2: {id: 2, name: 'Jane'}}
     * ```
     */
    arrayToMap<T>(arr: T[], keyField: keyof T): {
        [x: string]: T;
    };
    arrayToMap<T, NT>(arr: T[], keyField: keyof T, map: (item: T) => NT): {
        [x: string]: NT;
    };
    /**
     * Gets all the fields present in an array of objects
     * @param arr - Array of objects to analyze
     * @returns Object containing field names and their occurrence counts
     * @example
     * ```typescript
     * const data = [{name: 'John', age: 30}, {name: 'Jane', city: 'NY'}];
     * const fields = utility.getAllFieldsInArray(data);
     * // Result: {name: {field: 'name', count: 2}, age: {field: 'age', count: 1}, city: {field: 'city', count: 1}}
     * ```
     */
    getAllFieldsInArray: <T>(arr: T[]) => {
        [field: string]: {
            field: keyof T;
            count: number;
        };
    };
    /**
     * Formats a boolean value as 'Yes' or 'No'
     * @param v - Boolean value to format
     * @returns 'Yes' if true, 'No' if false
     */
    yesNoCellFormatter: (v?: boolean) => string;
    /**
     * Sorts object fields alphabetically
     * @param obj - Object to sort
     * @returns New object with sorted fields
     */
    sortObjectFields: <T>(obj: T) => T;
    /**
     * Copies a string to clipboard
     * @param str - String to copy
     * @returns Promise that resolves when copy is complete
     */
    copyString(str: string): Promise<void>;
    /**
     * Copies an object to clipboard as JSON string
     * @param payload - Object to copy
     * @returns Promise that resolves when copy is complete
     */
    copyObject(payload: Object): Promise<void>;
    /**
     * Returns first value if not null, otherwise returns second value
     * @param x - First value
     * @param y - Second value (defaults to '-')
     * @returns x if not null, otherwise y
     */
    xOrY: (x: any, y?: string) => string;
    /**
     * Converts Date string to DateTime string
     * @param dateStr - Date string to convert
     * @param config - Optional configuration
     * @returns DateTime string
     * @example
     * ```typescript
     * utility.dateToDateTime('2022-01-25'); // Returns '2022-01-25T00:00:00Z'
     * utility.dateToDateTime('2022-01-25', {omitT: true}); // Returns '2022-01-25 00:00:00'
     * ```
     */
    dateToDateTime: (dateStr: string, config?: {
        /**
         * Use the yyyy-mm-dd hh:mm:ss format
         */
        omitT?: boolean;
    }) => string;
    /**
     * Sets object fields if object exists
     * @param obj - Object to modify
     * @param kvps - Key-value pairs to set
     * @returns Modified object or null if input object is null
     */
    setterWithNull<T>(obj: T, kvps: Partial<T>): T;
    /**
     * Sets object fields for multiple objects
     * @param items - Array of objects and their modifications
     */
    setterWithNullArray<T>(items: {
        obj: T;
        kvps: Partial<T>;
    }[]): void;
    /**
     * Handles row deletion from an array
     * @param index - Index of row to delete
     * @param arr - Array containing rows
     * @param deleteService - Service to call for deletion
     * @param addRowFunc - Function to add new row
     * @param cb - Optional callback function
     */
    handleRowDelete: <T>(index: number, arr: any[], deleteService: (...args: any) => Promise<T> | Observable<T>, addRowFunc: (...args: any) => any, cb?: (any: any) => any) => Promise<void>;
    /**
     * Checks if value is a Promise
     * @param func - Value to check
     * @returns True if value is a Promise
     */
    private isPromise;
    /**
     * Checks if function is async
     * @param func - Function to check
     * @returns True if function is async
     */
    isAsync: (func: any) => boolean;
    /**
     * Checks if value is an Observable
     * @param func - Value to check
     * @returns True if value is an Observable
     */
    isObservable: <T>(func: any) => boolean;
    /**
     * Converts value to Promise
     * @param val - Value to convert
     * @returns Promise containing the value
     */
    promisifyVal: <T>(val: T | Promise<T> | Observable<T>) => Promise<Awaited<T>>;
    /**
     * Merges multiple observables into one
     * @param arr - Array of observables to merge
     * @returns Observable that emits merged responses
     */
    mergeArrObservables: <T>(arr: {
        $func: Observable<T[]>;
    }[]) => Observable<T[]>;
    /**
     * Removes duplicate items from array based on key field
     * @param list - Array to process
     * @param keyField - Field to check for duplicates (defaults to 'code')
     * @returns Array with duplicates removed
     */
    removeDuplicate<T>(list: T[], keyField?: string): T[];
    /**
     * Generates a random ID
     * @returns Random UUID
     */
    get genRandomID(): string;
    /**
     * Checks if object is empty
     * @param obj - Object to check
     * @param exclusionFields - Optional fields to exclude from check
     * @returns True if object is empty
     */
    objIsEmpty: (obj: any, exclusionFields?: string[]) => boolean;
    /**
     * Generates random data array
     * @param keys - Array of field names
     * @param length - Number of items to generate (defaults to 10)
     * @returns Array of generated objects
     */
    dataGen: <T = any>(keys: string[], length?: number) => T[];
    /**
     * Generates random text
     * @returns Random text string
     */
    textGen: () => string;
    /**
     * Track by function for ngFor using custom ID
     * @param index - Array index
     * @param item - Array item
     * @returns Custom ID for tracking
     */
    trackByCustomID: (index: any, item: any) => any;
    /**
     * Track by function for ngFor using code field
     * @param index - Array index
     * @param item - Array item
     * @returns Code value for tracking
     */
    trackByCode(index: number, item: any): any;
    /**
     * Track by function for ngFor using id field
     * @param index - Array index
     * @param item - Array item
     * @returns ID value for tracking
     */
    trackByID(index: number, item: any): any;
    /**
     * Finds label by item in array
     * @param item - Item to find
     * @param arr - Array to search in
     * @param labelField - Field to use as label
     * @param keyField - Field to use as key (defaults to 'code')
     * @returns Label string or item if not found
     */
    findLabelByItem: (item: any, arr: any[], labelField?: string, keyField?: string) => any;
    /**
     * Converts object to query parameters string
     * @param parameters - Object containing parameters
     * @returns Query string
     */
    objectToQueryParams(parameters?: Object): string;
    /**
     * Converts base64 string to Blob
     * @param base64Data - Base64 string
     * @param contentType - MIME type
     * @param sliceSize - Size of slices for conversion
     * @returns Blob object
     */
    base64toBlob: (base64Data: string, contentType?: string, sliceSize?: number) => Blob;
    /**
     * Converts base64 string to File
     * @param base64Data - Base64 string
     * @param fileName - Name of file
     * @param contentType - MIME type
     * @param sliceSize - Size of slices for conversion
     * @returns File object
     */
    base64toFile: (base64Data: string, fileName?: string, contentType?: string, sliceSize?: number) => File;
    /**
     * Extracts files from upload event
     * @param event - Upload event
     * @returns Array of files
     */
    extractUpload(event: any): File[];
    /**
     * Converts seconds to hours, minutes, seconds
     * @param seconds - Number of seconds
     * @returns Object containing hours, minutes, seconds
     */
    secondsToHourMinSec: (seconds: number) => {
        hours: number;
        mins: number;
        secs: number;
    };
    /**
     * Converts minutes to days, hours, minutes
     * @param minutes - Number of minutes
     * @returns Object containing days, hours, minutes
     */
    minutesToDayHourMin: (minutes: number) => {
        days: number;
        hours: number;
        mins: number;
    };
    /**
     * Converts minutes to formatted string
     * @param minutes - Number of minutes
     * @returns Formatted string (days hours:minutes)
     */
    minutesToDayHourMinStr: (minutes: number) => string;
    /**
     * Converts minutes to detailed formatted string
     * @param minutes - Number of minutes
     * @returns Formatted string (days days hours hrs minutes mins)
     */
    minutesToDayHourMinStr2: (minutes: number) => string;
    /**
     * Converts days, hours, minutes to hours:minutes format
     * @param dys - Number of days
     * @param hrs - Number of hours
     * @param mins - Number of minutes
     * @returns Formatted string (hours:minutes)
     */
    dayHourMinToHourMinutes: (dys: number, hrs: number, mins: number) => string;
    /**
     * Converts days, hours, minutes to total minutes
     * @param dys - Number of days
     * @param hrs - Number of hours
     * @param mins - Number of minutes
     * @returns Total number of minutes
     */
    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 number of minutes
     */
    hourMinToMinutes: (hrs: number, mins: number) => number;
    /**
     * Converts hours:minutes string to total minutes
     * @param hrsMins - String in format "hours:minutes"
     * @returns Total number of minutes
     */
    hourMinToMinutes2: (hrsMins: string) => number;
    /**
     * Scrolls to top of page
     * @param timeout - Delay before scrolling (defaults to 100ms)
     */
    scrollToTop: (timeout?: number) => NodeJS.Timeout;
    /**
     * Creates cell status formatter function
     * @param guide - Object containing success, error, and inert values
     * @returns Formatter function
     */
    cellStatusFormatter: (guide: {
        successVal?: any;
        errorVal?: any;
        inertVal?: any;
    }) => (v: any) => string;
    /**
     * Gets current local date time for datetime-local input
     * @returns Formatted date time string
     */
    getLocalDateTimeNow: () => string;
    /**
     * Gets current local date for date input
     * @returns Formatted date string
     */
    localDateNow: () => string;
    /**
     * Formats date according to specified format
     * @param date - Date to format
     * @param format - Format type (1-4)
     * @returns Formatted date string
     */
    dateFormat: (date: any, format?: number) => string;
    /**
     * Converts ISO date string to Java date string format
     * @param isoDateString - ISO date string
     * @returns Java formatted date string
     */
    toJavaDateString: (isoDateString?: string) => string;
    /**
     * Formats time string
     * @param time - Time string to format
     * @returns Formatted time string
     */
    timeFormat: (time?: any) => string;
    /**
     * Formats date using format type 1
     * @param date - Date to format
     * @returns Formatted date string
     */
    dateFormatter: (date: any) => string;
    /**
     * Formats number of days into readable string
     * @param days - Number of days
     * @returns Formatted string
     */
    daysFormatter: (days: number) => string;
    /**
     * Formats number of months into readable string
     * @param months - Number of months
     * @returns Formatted string
     */
    monthsFormatter: (months: number) => string;
    /**
     * Adds plural suffix to text based on value
     * @param val - Number value
     * @param txt - Text to pluralize
     * @param plural - Optional custom plural form
     * @returns Formatted string
     */
    pluarlizer: (val: number, txt: string, plural?: string) => string;
    /**
     * Converts decimal to percentage string
     * @param dec - Decimal value
     * @returns Percentage string
     */
    decimalToPercentage: (dec: number) => string;
    /**
     * Logs form object and its values
     * @param form - Form object to log
     */
    logForm: (form: any) => void;
    /**
     * Checks if file is an image based on extension
     * @param fileName - File name to check
     * @returns True if file is an image
     */
    isPictureFormat(fileName: string): boolean;
    /**
     * Converts object to array
     * @param obj - Object to convert
     * @returns Array of object values
     */
    objectToArray<T>(obj: any): T[];
    /**
     * Filter function to get unique values
     * @param value - Current value
     * @param index - Current index
     * @param self - Array being filtered
     * @returns True if value is unique
     */
    onlyUnique: <T>(value: T, index: number, self: T[]) => boolean;
    /**
     * Removes null, undefined, or empty string fields from object
     * @param obj - Object to clean
     * @returns Cleaned object or null if empty
     */
    deleteNull: <T>(obj: T) => T;
    /**
     * Converts object to text representation
     * @param obj - Object to convert
     * @returns Text representation of object
     */
    objectToText: (obj: any) => string;
    /**
     * Downloads file from URL
     * @param url - URL to download from
     * @param filename - Name to save file as
     */
    downloadFromLink(url: string, filename: string): Promise<void>;
    /**
     * Exports HTML content to PDF
     * @param content - HTML element to export
     * @param fileName - Name to save PDF as
     * @param config - PDF configuration
     * @returns Promise that resolves when PDF is saved
     */
    exportHTMLToPDF(content: HTMLElement, fileName: string, config: {
        width?: number;
        height?: number;
        orientation?: 'p' | 'portrait' | 'l' | 'landscape';
    }): Promise<void>;
    /**
     * Exports HTML content to PDF File object
     * @param content - HTML element to export
     * @param fileName - Name to save PDF as
     * @param config - PDF configuration
     * @returns Promise that resolves with PDF File object
     */
    exportHTMLToPDFObject(content: HTMLElement, fileName: string, config: {
        width?: number;
        height?: number;
        orientation?: 'p' | 'portrait' | 'l' | 'landscape';
    }): Promise<File>;
    /**
     * Exports array to CSV file
     * @param data - Array to export
     * @param filename - Name to save CSV as
     * @param headerMap - Optional header mapping
     */
    arrayToCSV(data: any[], filename: string, headerMap?: {
        f?: string;
        t?: string;
    }[]): void;
    /**
     * Adds days to date
     * @param days - Number of days to add
     * @param date - Date to add days to
     * @returns New date string
     */
    addDaysToDate(days: number, date: Date | string | number): string;
    /**
     * Generates random phone number
     * @returns Random phone number string
     */
    get genPhoneNumber(): string;
    /**
     * Generates UUID
     * @returns UUID string
     */
    generateUUID: () => string;
    /**
     * Formats time taken in milliseconds to readable string
     * @param timeTaken - Time in milliseconds
     * @returns Formatted time string
     */
    formatTimeTaken: (timeTaken: number) => string;
}

/**
 * Pipe that converts numbers to their word representation
 * @remarks
 * This pipe transforms numeric values into their written form, with optional suffix.
 * It uses the NumberToWordsService for conversion.
 *
 * @example
 * ```html
 * {{ 123 | numberToWords:'dollars' }} // Outputs: "one hundred twenty-three dollars"
 * ```
 */
declare class NumberToWordsPipe implements PipeTransform {
    ntw: NumberToWordsService;
    /**
     * Transforms a number into its word representation
     * @param value - The number to convert
     * @param suffix - Optional suffix to append to the result
     * @returns The word representation of the number with suffix if provided
     */
    transform(value: any, suffix: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberToWordsPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NumberToWordsPipe, "numberToWords", true>;
}
/**
 * Pipe that splits arrays into subarrays
 * @remarks
 * This pipe allows extracting a portion of an array based on start and end indices.
 *
 * @example
 * ```html
 * {{ [1,2,3,4,5] | arraySplitter:5:1:3 }} // Outputs: [2,3,4]
 * ```
 */
declare class ArraySplitter implements PipeTransform {
    /**
     * Splits an array into a subarray
     * @param arr - The array to split
     * @param arrLength - The length of the original array
     * @param startIndex - The index to start from (inclusive)
     * @param endIndex - The index to end at (inclusive)
     * @returns A subarray 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>;
}
/**
 * Pipe that formats gender codes into full words
 * @remarks
 * This pipe converts gender codes ('M'/'F') into their full word representations.
 *
 * @example
 * ```html
 * {{ 'M' | gender }} // Outputs: "Male"
 * ```
 */
declare class GenderPipe implements PipeTransform {
    /**
     * Transforms gender codes to full words
     * @param value - The gender code to transform
     * @returns The full gender word or original value if not recognized
     */
    transform(value: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenderPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GenderPipe, "gender", true>;
}
/**
 * Pipe that rounds numbers to the nearest integer
 * @remarks
 * This pipe uses Math.round to round numbers to the nearest whole number.
 *
 * @example
 * ```html
 * {{ 3.7 | round }} // Outputs: 4
 * ```
 */
declare class RoundPipe implements PipeTransform {
    /**
     * Rounds a number to the nearest integer
     * @param value - The number to round
     * @returns The rounded number
     */
    transform(value: number): number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RoundPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<RoundPipe, "round", true>;
}
/**
 * Pipe that converts seconds to a formatted time string
 * @remarks
 * This pipe converts a number of seconds into a human-readable time format
 * showing hours, minutes, and seconds.
 *
 * @example
 * ```html
 * {{ 3665 | secondsToTime }} // Outputs: "1hrs 1min 5s"
 * ```
 */
declare class SecondsToTimePipe implements PipeTransform {
    uS: UtilityServiceLite;
    /**
     * Converts seconds to a formatted time string
     * @param value - The number of seconds to convert
     * @returns A formatted time string showing hours, minutes, and seconds
     */
    transform(value: number): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SecondsToTimePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SecondsToTimePipe, "secondsToTime", true>;
}
/**
 * Pipe that formats counts into a more readable format
 * @remarks
 * This pipe formats large numbers into a more readable format (e.g., 1000 -> 1K).
 *
 * @example
 * ```html
 * {{ 1500 | formatCount }} // Outputs: "1.5K"
 * ```
 */
declare class FormatCountPipe implements PipeTransform {
    uS: UtilityServiceLite;
    /**
     * Formats a number count into a more readable format
     * @param value - The number to format
     * @returns The formatted count
     */
    transform(value: number): string | number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormatCountPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FormatCountPipe, "formatCount", true>;
}
/**
 * Pipe that gets a label for a value from an options array
 * @remarks
 * This pipe finds a matching value in an options array and returns its label.
 *
 * @example
 * ```html
 * {{ 'M' | getValueLabel:options:'description':'code' }} // Outputs: "M - Male"
 * ```
 */
declare class GetValueLabel implements PipeTransform {
    /**
     * Gets the label for a value from an options array
     * @param value - The value to find
     * @param options - The array of options to search in
     * @param labelField - The field containing the label
     * @param valueField - The field containing the value
     * @returns The formatted label or original value if not found
     */
    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>;
}
/**
 * Pipe that formats values using a custom formatter function
 * @remarks
 * This pipe applies a custom formatting function to a value.
 *
 * @example
 * ```html
 * {{ value | valueFormatter:formatFunction }}
 * ```
 */
declare class ValueFormatterPipe implements PipeTransform {
    /**
     * Formats a value using a custom formatter function
     * @param val - The value to format
     * @param formatter - The formatting function to apply
     * @returns The formatted value
     */
    transform(val: any, formatter: any): Promise<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueFormatterPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ValueFormatterPipe, "valueFormatter", true>;
}
/**
 * Base pipe for calling functions with arguments
 * @remarks
 * This pipe provides a way to call functions with arguments in templates.
 */
declare class FunctionCaller implements PipeTransform {
    /**
     * Calls a function with arguments
     * @param func - The function to call
     * @param args - The arguments to pass to the function
     * @returns The result of the function call
     */
    transform<T, P>(func: (...args: P[]) => T, ...args: P[]): T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionCaller, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller, "functionCaller", true>;
}
/**
 * Pipe that calls a function with one argument
 * @remarks
 * This pipe extends FunctionCaller to handle single-argument functions.
 */
declare class FunctionCaller1 extends FunctionCaller {
    /**
     * Calls a function with one argument
     * @param func - The function to call
     * @param param - The argument to pass
     * @returns The result of the function call
     */
    transform<T, P1>(func: (param: P1) => T, param: P1): T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionCaller1, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller1, "functionCaller1", true>;
}
/**
 * Pipe that calls a function with two arguments
 * @remarks
 * This pipe extends FunctionCaller to handle two-argument functions.
 */
declare class FunctionCaller2 extends FunctionCaller {
    /**
     * Calls a function with two arguments
     * @param func - The function to call
     * @param param1 - The first argument
     * @param param2 - The second argument
     * @returns The result of the function call
     */
    transform<T, P1, P2>(func: (param1: P1, param2: P2) => T, param1: P1, param2: P2): T;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunctionCaller2, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller2, "functionCaller2", true>;
}
/**
 * Pipe that calls a function with three arguments
 * @remarks
 * This pipe handles three-argument function calls in templates.
 */
declare class FunctionCaller3 implements PipeTransform {
    /**
     * Calls a function with three arguments
     * @param func - The function to call
     * @param param1 - The first argument
     * @param param2 - The second argument
     * @param param3 - The third argument
     * @returns The result of the function call
     */
    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<FunctionCaller3, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FunctionCaller3, "functionCaller3", true>;
}
/**
 * Pipe that makes HTTP list calls
 * @remarks
 * This pipe provides a way to make HTTP calls in templates.
 */
declare class HttpListCaller implements PipeTransform {
    /**
     * Makes an HTTP call
     * @param httpObservable - The HTTP observable to call
     * @returns The result of the HTTP call
     */
    transform<T>(httpObservable: () => Observable<T>): Observable<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpListCaller, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HttpListCaller, "httpListCaller", true>;
}
/**
 * Pipe that makes HTTP list calls with one parameter
 * @remarks
 * This pipe extends HttpListCaller to handle single-parameter HTTP calls.
 */
declare class HttpListCaller1 implements PipeTransform {
    /**
     * Makes an HTTP call with one parameter
     * @param httpObservable - The HTTP observable to call
     * @param param - The parameter to pass
     * @returns The result of the HTTP call
     */
    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>;
}
/**
 * Pipe that makes HTTP list calls with two parameters
 * @remarks
 * This pipe extends HttpListCaller to handle two-parameter HTTP calls.
 */
declare class HttpListCaller2 implements PipeTransform {
    /**
     * Makes an HTTP call with two parameters
     * @param httpObservable - The HTTP observable to call
     * @param param1 - The first parameter
     * @param param2 - The second parameter
     * @returns The result of the HTTP call
     */
    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>;
}
/**
 * Pipe that checks if a page is a show page
 * @remarks
 * This pipe determines if a given page type is a view/show page.
 */
declare class IsShowPage implements PipeTransform {
    /**
     * Checks if a page type is a show page
     * @param type - The page type to check
     * @returns true if the page is a show page
     */
    transform(type: EPageType): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsShowPage, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsShowPage, "isShowPage", true>;
}
/**
 * Pipe that checks if a page is a clone page
 * @remarks
 * This pipe determines if a given page type is a clone page.
 */
declare class IsClonePage implements PipeTransform {
    /**
     * Checks if a page type is a clone page
     * @param type - The page type to check
     * @returns true if the page is a clone page
     */
    transform(type: EPageType): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IsClonePage, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IsClonePage, "isClonePage", true>;
}
/**
 * Pipe that filters arrays based on a value and key
 * @remarks
 * This pipe filters an array based on matching a value in a specific key.
 */
declare class FilterArrayPipe implements PipeTransform {
    /**
     * Filters an array based on a value and key
     * @param arr - The array to filter
     * @param value - The value to match
     * @param key - The key to check
     * @param filterFunction - Optional custom filter function
     * @returns The filtered array
     */
    transform<T>(arr: T[], value: any, key: keyof T, filterFunction?: (value: T, index?: number, array?: T[]) => boolean): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterArrayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterArrayPipe, "filterArray", true>;
}
/**
 * Pipe that filters arrays based on string matching
 * @remarks
 * This pipe filters an array based on string matching in multiple keys.
 */
declare class FilterArrayByStringPipe implements PipeTransform {
    /**
     * Filters an array based on string matching
     * @param arr - The array to filter
     * @param value - The string to match
     * @param keys - The keys to check
     * @param filterFunction - Optional custom filter function
     * @returns The filtered array
     */
    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>;
}
/**
 * Pipe that filters form arrays
 * @remarks
 * This pipe filters a form array based on matching a value in a specific key.
 */
declare class FilterFormArrayPipe implements PipeTransform {
    /**
     * Filters a form array based on a value and key
     * @param arr - The form array to filter
     * @param value - The value to match
     * @param key - The key to check
     * @returns The filtered form array
     */
    transform(arr: AbstractControl[], value: any, key?: string): AbstractControl<any, any, any>[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterFormArrayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterFormArrayPipe, "filterFormArray", true>;
}
/**
 * Pipe that sorts arrays
 * @remarks
 * This pipe sorts an array based on a field and direction.
 */
declare class SortPipe implements PipeTransform {
    /**
     * Sorts an array based on a field and direction
     * @param arr - The array to sort
     * @param direction - The sort direction (0=ascending, 1=descending)
     * @param sortField - The field to sort by
     * @returns The sorted array
     */
    transform<T>(arr: T[], direction?: 0 | 1, sortField?: keyof T): T[];
    /**
     * Internal sorting method
     * @param arr - The array to sort
     * @param direction - The sort direction
     * @param sortField - The field to sort by
     * @returns The sorted array
     */
    sort<T>(arr: T[], direction: 0 | 1, sortField?: keyof T): T[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SortPipe, "sort", true>;
}
/**
 * Pipe that converts values to any type
 * @remarks
 * This pipe provides type conversion to any type.
 */
declare class ToAnyPipe implements PipeTransform {
    /**
     * Converts a value to any type
     * @param value - The value to convert
     * @param isArray - Whether to convert to array
     * @returns The converted value
     */
    transform(value: any, isArray?: boolean): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToAnyPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToAnyPipe, "toAny", true>;
}
/**
 * Pipe that converts values to any array
 * @remarks
 * This pipe converts values to any array type.
 */
declare class ToAnyArrayPipe implements PipeTransform {
    /**
     * Converts a value to any array type
     * @param value - The value to convert
     * @returns The value as any array
     */
    transform(value: any): any[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToAnyArrayPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ToAnyArrayPipe, "toAnyArray", true>;
}
/**
 * Pipe that trims text to a specified length
 * @remarks
 * This pipe truncates text and adds ellipsis if it exceeds the specified length.
 */
declare class TrimTextPipe implements PipeTransform {
    /**
     * Trims text to a specified length
     * @param value - The text to trim
     * @param length - The maximum length
     * @returns The trimmed text with ellipsis if truncated
     */
    transform(value: string | undefined, length: number): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrimTextPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TrimTextPipe, "trimText", true>;
}
/**
 * Pipe that trims whitespace from strings
 * @remarks
 * This pipe removes leading and trailing whitespace from strings.
 */
declare class TrimPipe implements PipeTransform {
    /**
     * Trims whitespace from a string
     * @param value - The string to trim
     * @returns The trimmed string
     */
    transform(value?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrimPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TrimPipe, "trim", true>;
}
/**
 * Pipe that returns x or y based on value
 * @remarks
 * This pipe returns x if not empty, otherwise returns y.
 */
declare class XOrYPipe implements PipeTransform {
    private uS;
    /**
     * Returns x if not empty, otherwise returns y
     * @param x - The primary value
     * @param y - The default value
     * @returns x if not empty, otherwise y
     */
    transform(x: string, y?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XOrYPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<XOrYPipe, "xOrY", true>;
}
/**
 * Pipe that replaces all occurrences of a string
 * @remarks
 * This pipe replaces all occurrences of a search string with a replacement string.
 */
declare class ReplaceAllPipe implements PipeTransform {
    /**
     * Replaces all occurrences of a string
     * @param text - The text to modify
     * @param search - The string to replace
     * @param replacement - The replacement string
     * @returns The modified text
     */
    transform(text: string, search: string, replacement: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReplaceAllPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ReplaceAllPipe, "replaceAll", true>;
}
/**
 * Pipe that returns a value or default
 * @remarks
 * This pipe returns the value if not null/undefined, otherwise returns a default value.
 */
declare class ValueOrXPipe implements PipeTransform {
    /**
     * Returns a value or default
     * @param value - The value to check
     * @param replacement - The default value
     * @returns The value if not null/undefined, otherwise the default value
     */
    transform<TV>(value: TV): string;
    transform<TV, TR>(value: TV, replacement?: TR): TV | TR;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueOrXPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ValueOrXPipe, "valueOrX", true>;
}
/**
 * Pipe that concatenates strings
 * @remarks
 * This pipe joins two strings with an optional joiner.
 */
declare class StrConcatenatorPipe implements PipeTransform {
    /**
     * Concatenates strings with a joiner
     * @param text1 - The first text
     * @param text2 - The second text
     * @param joiner - The joiner string
     * @returns The concatenated string
     */
    transform<T>(text1: string | symbol | number, text2: string | symbol, joiner?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrConcatenatorPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<StrConcatenatorPipe, "strConcatenator", true>;
}
/**
 * Pipe that formats dates with custom options
 * @remarks
 * This pipe formats dates with options for showing time and special cases for today/yesterday.
 */
declare class CustomDatePipe implements PipeTransform {
    datePipe: DatePipe;
    /**
     * Formats a date with custom options
     * @param date - The date to format
     * @param showTime - Whether to show time
     * @returns The formatted date string
     */
    transform(date: string, showTime?: boolean): string;
    /**
     * Formats a date with a custom format string
     * @param date - The date to format
     * @param formatStr - The format string
     * @returns The formatted date string
     */
    transform2(date: string, formatStr: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CustomDatePipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CustomDatePipe, "customDate", true>;
}
/**
 * Pipe that shows how long ago a date was
 * @remarks
 * This pipe converts a date into a human-readable "time ago" string.
 */
declare class DateAgoPipe implements PipeTransform {
    /**
     * Shows how long ago a date was
     * @param value - The date to check
     * @param startFrom - The threshold for "Just now" in seconds
     * @returns A human-readable time ago string
     */
    transform(value: string | Date | number, startFrom?: number): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateAgoPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DateAgoPipe, "dateAgo", true>;
}
declare class UtilityPipesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UtilityPipesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<UtilityPipesModule, never, [typeof i1.CommonModule, typeof ArraySplitter, typeof CustomDatePipe, typeof DateAgoPipe, typeof FilterArrayByStringPipe, typeof FilterArrayPipe, typeof FilterFormArrayPipe, typeof FormatCountPipe, typeof FunctionCaller, typeof FunctionCaller1, typeof FunctionCaller2, typeof FunctionCaller3, typeof GenderPipe, typeof GetValueLabel, typeof HttpListCaller, typeof HttpListCaller1, typeof HttpListCaller2, typeof IsClonePage, typeof IsShowPage, typeof NumberToWordsPipe, typeof TrimPipe, typeof ReplaceAllPipe, typeof RoundPipe, typeof SecondsToTimePipe, typeof SortPipe, typeof StrConcatenatorPipe, typeof ToAnyArrayPipe, typeof ToAnyPipe, typeof TrimTextPipe, typeof ValueFormatterPipe, typeof ValueOrXPipe, typeof XOrYPipe], [typeof ArraySplitter, typeof CustomDatePipe, typeof DateAgoPipe, typeof FilterArrayByStringPipe, typeof FilterArrayPipe, typeof FilterFormArrayPipe, typeof FormatCountPipe, typeof FunctionCaller, typeof FunctionCaller1, typeof FunctionCaller2, typeof FunctionCaller3, typeof GenderPipe, typeof GetValueLabel, typeof HttpListCaller, typeof HttpListCaller1, typeof HttpListCaller2, typeof IsClonePage, typeof IsShowPage, typeof NumberToWordsPipe, typeof TrimPipe, typeof ReplaceAllPipe, typeof RoundPipe, typeof SecondsToTimePipe, typeof SortPipe, typeof StrConcatenatorPipe, typeof ToAnyArrayPipe, typeof ToAnyPipe, typeof TrimTextPipe, typeof ValueFormatterPipe, typeof ValueOrXPipe, typeof XOrYPipe]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<UtilityPipesModule>;
}

declare class UtilityServiceLite extends UtilityClass {
    /**
     * Emits true if mobile
     */
    mobileQueryChanged: ReplaySubject<boolean>;
    /**
     * Indicates whether the current device is mobile
     */
    isMobile: boolean;
    /**
     * Environment configuration
     */
    environment: herlhay_helpers.Environment;
    /**
     * Angular Router service
     */
    router: Router;
    /**
     * Title service for managing document title
     */
    titleS: Title;
    /**
     * Location service for navigation
     */
    location: Location;
    /**
     * Decimal pipe for number formatting
     */
    numberPipe: DecimalPipe;
    /**
     * Currency pipe for currency formatting
     */
    currencyPipe: CurrencyPipe;
    /**
     * Custom date pipe for date formatting
     */
    customDatePipe: CustomDatePipe;
    /**
     * Title case pipe for text formatting
     */
    titleCasePipe: TitleCasePipe;
    /**
     * Breakpoint observer for responsive design
     */
    responsive: BreakpointObserver;
    /**
     * Signal that indicates if the current device is mobile
     */
    isMobileSignal: _angular_core.Signal<boolean>;
    constructor();
    /**
     * Navigates back to the previous page
     */
    back: () => void;
    /**
     * Creates a subscription manager to handle multiple subscriptions
     * @param subs - Initial subscriptions to manage
     * @returns Object with methods to clear and add subscriptions
     */
    createSubscriptionManager: (...subs: Subscription[]) => {
        clear: () => void;
        push: (...subs: Subscription[]) => void;
    };
    /**
     * Ensures only one input from a group can be active at a time
     * @param inputs - Array of form controls to manage
     */
    onlyOneInput(inputs: FormControl[]): void;
    /**
     * Converts text to title case
     * @param text - The text to convert
     * @returns The text in title case
     */
    toTitleCase(text: string): string;
    /**
     * 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 emitEvent Specify whether to emit an event when manipulating the FormArray
     * @returns Promise that resolves after deletion is complete
     */
    handleFormRowDelete: (index: number, fa: UntypedFormArray, deleteService: ((...args: any) => Promise<any> | Observable<any>) | null, addRowFunc: (...args: any) => any, emitEvent?: boolean) => Promise<any>;
    /**
     * Map of number ranges for formatting counts
     */
    countMap: {
        thousand: {
            min1: number;
            max1: number;
            min2: number;
            max2: number;
        };
        mil: {
            min1: number;
            max1: number;
            min2: number;
            max2: number;
        };
        bil: {
            min1: number;
            max1: number;
            min2: number;
            max2: number;
        };
        tril: {
            min1: number;
            max1: number;
            min2: number;
            max2: number;
        };
    };
    /**
     * Formats a number with appropriate suffix (K, M, B, TR)
     * @param num - The number to format
     * @returns Formatted number as string
     */
    formatCount: (num: number) => string;
    /**
     * Initializes and patches a FormArray with data
     * @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: (arr: any[], addFunc: (i: number, data?: any, formArr?: FormArray) => void, formArr: FormArray) => void;
    /**
     * Track by function for form arrays
     * @param index - The index of the item
     * @param item - The form group item
     * @returns A unique identifier for the item
     */
    trackByForForms: (index: any, item: FormGroup) => any;
    /**
     * Navigates to a specified route
     * @param value - The route to navigate to
     * @param extra - Optional navigation extras
     */
    go: (value: string, extra?: NavigationExtras) => void;
    /**
     * Creates a relative router helper
     * @returns Object with router navigation helpers
     */
    relativeRouter(): {
        route: ActivatedRoute;
        router: Router;
        navigate: (link: string, config?: NavigationExtras | undefined) => Promise<boolean>;
        queryParams: i1$1.Params;
        pathParams: i1$1.Params;
    };
    /**
     * Route to component using relative navigation
     * @param route Route of path to component
     * @param extra Additional navigation options
     */
    goR: (route: string, extra?: NavigationExtras) => void;
    /**
     * Route to the redirect component
     * @param route Absolute path to redirect to
     * @param config Configuration for the redirection
     */
    redirect: (route: string, config?: {
        /**
         * Specify if the redirect route is an app route or external route
         */
        isExternal?: boolean;
        /**
         * Specify if to open in a new tab or current tab
         */
        newTab?: boolean;
    }) => void;
    /**
     * Open route in a new tab
     * @param route Route path
     * @param queryParams Optional query parameters
     */
    openInTab(route: string, queryParams?: {
        [x: string]: string | number;
    }): void;
    /**
     * Formats a number as currency
     * @param amount - The amount to format
     * @param currency - The currency symbol to use
     * @returns Formatted currency string
     */
    moneyParser: (amount: string | number, currency?: string) => string;
    /**
     * Disables or enables a collection of form controls
     * @param controls - The controls to modify
     * @param disable - Whether to disable or enable the controls
     */
    disableOrEnableInputs: (controls: AbstractControl[], disable: boolean) => void;
    /**
     * Disables a collection of form controls
     * @param controls - The controls to disable
     */
    disableInputs: (controls: AbstractControl[]) => void;
    /**
     * Enables a collection of form controls
     * @param controls - The controls to enable
     */
    enableInputs: (controls: AbstractControl[]) => void;
    /**
     * Shows a notification to the user
     * @param message - The message to display
     * @param cls - The notification class/type
     * @param duration - How long to show the notification
     * @param title - Optional title for the notification
     * @param extraConfig - Additional configuration options
     */
    notify: (message: string, cls?: 0 | 1 | 2 | 3, duration?: number, title?: string, extraConfig?: {
        [x: string]: any;
    }) => any;
    /**
     * Formats a timestamp as a full date and time
     * @param timestamp - The timestamp to format
     * @param format - The format string to use
     * @returns Formatted date and time string
     * @example `Fri Feb 03 2023, 11:59 pm`
     */
    fullDateTime: (timestamp: string | number, format?: string) => string;
    /**
     * Formats a timestamp as a lean date and time
     * @param timestamp - The timestamp to format
     * @returns Formatted date and time string
     */
    fullDateTimeLean: (timestamp: string | number) => string;
    /**
     * Formats a date for user experience
     * @param date - The date to format
     * @returns Formatted date string
     */
    dateFormatterUX: (date: any) => string;
    /**
     * Formats a date with time
     * @param date - The date to format
     * @returns Formatted date and time string
     */
    dateTimeFormatter: (date: any) => string;
    /**
     * Exports HTML content to PDF
     * @param contents - QueryList of ElementRefs containing HTML to export
     * @param fileName - Name for the exported PDF file
     * @param config - Configuration options for the PDF
     * @returns Promise that resolves when PDF is saved
     */
    exportHTMLsToPDF(contents: QueryList<ElementRef<HTMLDivElement>>, fileName: string, config: {
        width?: number;
        height?: number;
        orientation?: 'p' | 'portrait' | 'l' | 'landscape';
    }): Promise<void>;
    /**
     * Shows a notification that the user doesn't have access
     */
    noAccessNotify(): void;
    /**
     * Validates a phone number format
     * @param control - The form control containing the phone number
     * @returns Validation error or null if valid
     */
    validatePhonenumber(control: FormControl<string>): CustomValidationError;
    /**
     * Subscribes to route changes and executes a callback
     * @param route - The activated route
     * @param router - The router service
     * @param onRouteChangeCB - Callback to execute when route changes
     * @returns The subscription
     */
    onRouteChange: (route: ActivatedRoute, router: Router, onRouteChangeCB: (routeDataParams: any) => any) => Subscription;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UtilityServiceLite, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UtilityServiceLite>;
}

/**
 * Service for handling input-related functionality
 * @remarks
 * This service provides utilities for handling various input types, including date/time inputs,
 * option formatting, and validation.
 *
 * @example
 * ```typescript
 * constructor(private inputService: InputService) {}
 *
 * // Format options for a select input
 * const options = this.inputService.optionsFormatter(
 *   rawOptions,
 *   'id',
 *   null,
 *   'cdt'
 * );
 * ```
 */
declare class InputService {
    /** Default values for input configuration */
    readonly defaultValue: {
        showSeperateLabel: boolean;
        showValidationMsg: boolean;
        useMatLabel: boolean;
        appearance: MatFormFieldAppearance;
    };
    /** Available hours for time selection */
    readonly timeHours: _angular_core.WritableSignal<(string | number)[]>;
    /** Available minutes for time selection */
    readonly timeMinutes: _angular_core.WritableSignal<(string | number)[]>;
    /** Available seconds for time selection */
    readonly timeSeconds: _angular_core.WritableSignal<(string | number)[]>;
    /** AM/PM options for time selection */
    readonly timeMeridiem: _angular_core.WritableSignal<{
        label: "am" | "pm";
        incrementor: 0 | 12;
    }[]>;
    /** Computed map of meridiem options */
    readonly timeMeridiemMap: _angular_core.Signal<{
        [x: string]: {
            _label: string;
            label: "am" | "pm";
            incrementor: 0 | 12;
        };
    }>;
    /** Length of date components */
    readonly dateLengthIndex: {
        0: number;
        1: number;
        2: number;
    };
    /** Configuration for date input chunks */
    readonly dateInputChunks: {
        placeholder?: string;
        label: string;
        class: string;
        width: string;
        seperator?: string;
        formControlName: string;
        type: InputType;
        length: number;
        isTime?: boolean;
    }[];
    /**
     * Gets a form group for date input
     * @returns Form group with date and time controls
     */
    get dateFS(): FormGroup<{
        date: FormControl<Date>;
        hours: FormControl<string>;
        minutes: FormControl<string>;
        seconds: FormControl<string>;
        meridiem: FormControl<number>;
        rawValue: FormControl<string>;
    }>;
    /** Functions for formatting option labels */
    readonly optionLabellerFunctions: {
        [x: string]: (option: any) => {
            label: string;
            value: string;
        };
    };
    constructor();
    /**
     * Formats a label from two fields
     * @param field1 - First field value
     * @param field2 - Second field value
     * @returns Object with value and formatted label
     */
    labeller: (field1: string, field2: string) => {
        value: string;
        label: string;
    };
    /**
     * Formats options for select inputs
     * @param options - Array of options to format
     * @param valueField - Field to use for option values
     * @param formatter - Custom formatter function
     * @param labelType - Type of label formatting to apply
     * @param labelField - Field(s) to use for option labels
     * @param autoPickValueField - Whether to automatically pick value field
     * @returns Array of formatted options
     */
    optionsFormatter: <TRow>(options: any[], valueField?: keyof TRow, formatter?: any, labelType?: OptionLabelType, labelField?: keyof TRow | (keyof TRow)[], autoPickValueField?: boolean) => {
        value: any;
        label: any;
    }[];
    /**
     * Gets the value to track by for options
     * @param index - Option index
     * @param item - Option item
     * @returns Value to track by
     */
    trackByValue(index: any, item: IOption): any;
    /**
     * Formats user input for date/time fields
     * @param e - Input event
     * @param form - Form group to update
     * @param showTime - Whether to show time fields
     * @param id - Input element ID
     */
    formatUserInput(e: Event, form: typeof this.dateFS, showTime: boolean, id: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InputService>;
}

/**
 * Component for handling date input with optional time selection
 * @remarks
 * This component provides a date picker with optional time selection capabilities.
 * It supports various date formats and time configurations.
 *
 * @example
 * ```html
 * <date-input
 *   [value]="'2023-12-31T14:30:00'"
 *   [showTime]="true"
 *   (valueChanged)="onDateChange($event)"
 * ></date-input>
 * ```
 */
declare class DateInputComponent {
    iS: InputService;
    datePipe: DatePipe;
    destroyRef: DestroyRef;
    /** Type of input field */
    type: string;
    /** Length of date/time chunks */
    chunksLength: number;
    /** Form group containing date and time controls */
    protected form: FormGroup<{
        date: FormControl<Date>;
        hours: FormControl<string>;
        minutes: FormControl<string>;
        seconds: FormControl<string>;
        meridiem: FormControl<number>;
        rawValue: FormControl<string>;
    }>;
    /** Computed formatted value of the date/time */
    formattedValue: _angular_core.Signal<string>;
    /** Signal containing the current form value */
    readonly formValue: _angular_core.Signal<Partial<{
        date: Date;
        hours: string;
        minutes: string;
        seconds: string;
        meridiem: number;
        rawValue: string;
    }>>;
    /** Event emitter for value changes */
    valueChanged: EventEmitter<string>;
    /** Signal indicating whether to show time selection */
    showTime: _angular_core.WritableSignal<boolean>;
    /** Flag to skip patching from control */
    skipPatchFromControl: boolean;
    /** Flag to skip patching control */
    skipPatchControl: boolean;
    /** Current control value */
    controlValue: string;
    /**
     * Sets the input value and updates the form controls
     * @param v - The date/time value to set
     */
    set value(v: string);
    /** Input class for styling */
    inpCl: _angular_core.InputSignal<string>;
    /** Additional CSS classes */
    cls: _angular_core.InputSignal<string>;
    /** Input-specific CSS class */
    inputClass: _angular_core.InputSignal<string>;
    /** Validation state */
    valid: boolean;
    /** Maximum allowed date */
    readonly max: _angular_core.InputSignal<string | number>;
    readonly computedMax: _angular_core.Signal<Date>;
    readonly min: _angular_core.InputSignal<string | number>;
    readonly computedMin: _angular_core.Signal<Date>;
    /** Input element ID */
    id: _angular_core.InputSignal<string>;
    /** Invalid state */
    invalid: boolean;
    /** Disabled state */
    disabled: _angular_core.InputSignal<boolean>;
    /** Debug mode */
    debug: _angular_core.InputSignal<boolean>;
    /** Readonly state */
    readonly: _angular_core.InputSignal<boolean>;
    /** Sets the input type and configures time display */
    set _type(v: InputType);
    /** Show validation state */
    showValidation: boolean;
    /** Reference to the calendar component */
    matCalendar: MatCalendar<any>;
    /** Subscriptions map */
    subs: {
        [x: string]: Subscription;
    };
    constructor();
    /**
     * Sets up the form value change subscription
     */
    formatterFunction: () => void;
    /**
     * Cleanup subscriptions on component destruction
     */
    ngOnDestroy(): void;
    /**
     * Initialize calendar view after component initialization
     */
    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; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "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>;
}

/**
 * Pipe for filtering options based on a query string
 * @remarks
 * This pipe filters an array of options based on a query string, prioritizing matches
 * that start with the query.
 *
 * @example
 * ```html
 * <div *ngFor="let option of options | filterOptions:query:'label'">
 *   {{option.label}}
 * </div>
 * ```
 */
declare class FilterOptions implements PipeTransform {
    /**
     * Transforms an array of options by filtering based on a query
     * @param arr - Array of options to filter
     * @param query - Query string to filter by
     * @param field - Field to search in (defaults to 'label')
     * @returns Filtered array of options
     */
    transform(arr: any[], query: string, field?: string): any[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterOptions, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterOptions, "filterOptions", true>;
}
/**
 * Pipe for formatting options with labels and values
 * @remarks
 * This pipe formats an array of options into a standardized format with label and value properties.
 *
 * @example
 * ```html
 * <select>
 *   <option *ngFor="let option of items | optioner:'name':'id'"
 *           [value]="option.value">
 *     {{option.label}}
 *   </option>
 * </select>
 * ```
 */
declare class OptionerPipe implements PipeTransform {
    /**
     * Transforms an array of items into options with labels and values
     * @param options - Array of items to transform
     * @param labelField - Field(s) to use for the label
     * @param idField - Field to use for the value
     * @param basic - Whether to use basic formatting
     * @returns Array of formatted options
     */
    transform(options: any[], labelField: any, idField?: any, basic?: boolean): {
        value: any;
        label: string;
    }[];
    /**
     * Converts an array of fields into a string label
     * @param labelField - Field(s) to use for the label
     * @param x - Item to get values from
     * @returns Formatted label string
     */
    arrToStr(labelField: string, x: any): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionerPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<OptionerPipe, "optioner", true>;
}
/**
 * Pipe for formatting validation messages
 * @remarks
 * This pipe adds prefix and suffix to validation messages.
 *
 * @example
 * ```html
 * <div>{{errorMessage | validationMsg:'Error:':'.'}}</div>
 * ```
 */
declare class ValidationMsg implements PipeTransform {
    /**
     * Transforms a message by adding prefix and suffix
     * @param message - Message to transform
     * @param prefix - Prefix to add
     * @param suffix - Suffix to add
     * @returns Formatted message
     */
    transform(message: string, prefix?: string, suffix?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationMsg, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ValidationMsg, "validationMsg", true>;
}
/**
 * Pipe for checking validation state
 * @remarks
 * This pipe checks if a control has a specific validation error.
 *
 * @example
 * ```html
 * <div *ngIf="control | validator:validation">
 *   Validation error
 * </div>
 * ```
 */
declare class Validator implements PipeTransform {
    /**
     * Checks if a control has a specific validation error
     * @param validation - Validation type to check
     * @param control - Form control to check
     * @param update - Whether to update validation state
     * @returns Whether the validation error exists
     */
    transform(validation: any, control: AbstractControl, update?: any): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Validator, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<Validator, "validator", true>;
}
/**
 * Pipe for formatting option labels
 * @remarks
 * This pipe formats option labels based on a specified type or custom formatter.
 *
 * @example
 * ```html
 * <div>{{option | optionLabeller:null:'cdt'}}</div>
 * ```
 */
declare class OptionLabeller implements PipeTransform {
    iS: InputService;
    /**
     * Transforms an option into a formatted label
     * @param option - Option to format
     * @param formatter - Custom formatter function
     * @param optionType - Type of label formatting to apply
     * @param labelField - Field to use for the label
     * @returns Formatted label
     */
    transform(option: any, formatter?: any, optionType?: OptionLabelType, labelField?: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionLabeller, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<OptionLabeller, "optionLabeller", true>;
}
/**
 * Pipe for formatting arrays of options
 * @remarks
 * This pipe formats an array of options using the InputService's optionsFormatter.
 *
 * @example
 * ```html
 * <select>
 *   <option *ngFor="let option of items | optionsFormatter:'id':null:'cdt'"
 *           [value]="option.value">
 *     {{option.label}}
 *   </option>
 * </select>
 * ```
 */
declare class OptionsFormatter implements PipeTransform {
    iS: InputService;
    /**
     * Transforms an array of options using the InputService's formatter
     * @param options - Array of options to format
     * @param valueField - Field to use for option values
     * @param formatter - Custom formatter function
     * @param optionType - Type of label formatting to apply
     * @param labelField - Field to use for option labels
     * @returns Array of formatted options
     */
    transform(options: any[], valueField?: string, formatter?: any, optionType?: OptionLabelType, labelField?: string): IOption[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionsFormatter, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<OptionsFormatter, "optionsFormatter", true>;
}
/**
 * Pipe for applying input classes based on validation state
 * @remarks
 * This pipe applies CSS classes to inputs based on their validation state.
 *
 * @example
 * ```html
 * <input [class]="'input-field' | inputClass:valid:invalid:showValidation">
 * ```
 */
declare class InputClassPipe implements PipeTransform {
    /**
     * Transforms input classes based on validation state
     * @param inpCl - Base input class
     * @param valid - Whether the input is valid
     * @param invalid - Whether the input is invalid
     * @param showValidation - Whether to show validation state
     * @returns Combined CSS classes
     */
    transform(inpCl: string, valid?: boolean, invalid?: boolean, showValidation?: boolean): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputClassPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<InputClassPipe, "inputClass", true>;
}
/**
 * Module containing all input-related pipes
 * @remarks
 * This module exports all the input-related pipes and required dependencies.
 */
declare class InputPipesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputPipesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<InputPipesModule, never, [typeof i1.CommonModule, typeof _angular_forms.FormsModule, 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, typeof _angular_forms.FormsModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<InputPipesModule>;
}

/**
 * Pipe for transforming validation messages
 * @remarks
 * This pipe processes validation messages based on control errors and validation type
 */
declare class ErrorMessagesPipe implements PipeTransform {
    errMsgPipe: ErrorMessagePipe;
    /**
     * Transforms validation messages based on control errors
     * @param validations - Array of validation messages
     * @param label - Field label
     * @param maxLength - Maximum length for validation
     * @param minLength - Minimum length for validation
     * @param control - Form control to validate
     * @returns Formatted error message string
     */
    transform(validations: IValidationMessage[], label: string, maxLength: number, minLength: number, control: FormControl): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorMessagesPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ErrorMessagesPipe, "errorMessages", true>;
}
/**
 * Pipe for formatting individual error messages
 * @remarks
 * This pipe formats error messages with proper labels and placeholders
 */
declare class ErrorMessagePipe implements PipeTransform {
    /**
     * Transforms an error message with proper formatting
     * @param errObj - Validation message object
     * @param label - Field label
     * @param maxLength - Maximum length for validation
     * @param minLength - Minimum length for validation
     * @param controlMessage - Custom error message
     * @returns Formatted error message
     */
    transform(errObj: 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>;
}
/**
 * Component for displaying validation messages
 * @remarks
 * This component displays validation messages for form controls with proper formatting
 *
 * @example
 * ```html
 * <app-validation-message
 *   [validationKey]="validationType"
 *   [control]="formControl"
 *   [label]="'Field Name'"
 * ></app-validation-message>
 * ```
 */
declare class ValidationMessageComponent implements OnInit {
    /** Type of validation to apply */
    validationType: EValidationType;
    /** Sets the validation type and retrieves corresponding messages */
    set _validationKey(v: EValidationType);
    /** Form control to validate */
    readonly _control: _angular_core.InputSignal<AbstractControl<any, any, any>>;
    /** Field label */
    readonly _label: _angular_core.InputSignal<string>;
    /** Minimum length for validation */
    minLength: number;
    /** Maximum length for validation */
    maxLength: number;
    /** Custom error message */
    customMessage: 'Value is invalid';
    /** Computed array of error messages */
    readonly errors: _angular_core.Signal<any[]>;
    /** Array of validation messages */
    validations: IValidationMessage[];
    constructor();
    /**
     * Initializes the component with default validation type if none provided
     */
    ngOnInit(): void;
    /** Computed field label */
    readonly label: _angular_core.Signal<string>;
    /** Computed form control */
    readonly control: _angular_core.Signal<AbstractControl<any, any, any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValidationMessageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValidationMessageComponent, "app-validation-message", never, { "_validationKey": { "alias": "validationKey"; "required": false; }; "_control": { "alias": "control"; "required": false; "isSignal": true; }; "_label": { "alias": "label"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "customMessage": { "alias": "customMessage"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Service for managing SVG icons
 * @remarks
 * This service provides functionality to register and retrieve SVG icons.
 * It maintains a registry of SVG strings mapped to icon names.
 *
 * @example
 * ```typescript
 * // Register a new icon
 * svgIconS.registerSVGIcons([{ iconName: 'custom', svgStr: '<svg>...</svg>' }]);
 *
 * // Get an SVG string
 * const svg = svgIconS.getSVG('search');
 * ```
 */
declare class SvgIconService {
    /**
     * Registry of SVG icons
     * @remarks
     * Maps icon names to their SVG string representations
     */
    icons: {
        [icon in SVGIconType]: string;
    };
    constructor();
    /**
     * Retrieves an SVG string for a given icon name
     * @param icon - The name of the icon to retrieve
     * @returns Object containing the SVG string and icon name
     *
     * @example
     * ```typescript
     * const result = svgIconS.getSVG('search');
     * console.log(result.icon); // '<svg>...</svg>'
     * ```
     */
    getSVG(icon: string): {
        icon: string;
    };
    /**
     * Registers new SVG icons
     * @param icons - Array of icon objects containing name and SVG string
     *
     * @example
     * ```typescript
     * svgIconS.registerSVGIcons([
     *   { iconName: 'custom', svgStr: '<svg>...</svg>' }
     * ]);
     * ```
     */
    registerSVGIcons: (icons: {
        iconName: string;
        svgStr: string;
    }[]) => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvgIconService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SvgIconService>;
}

/**
 * Component for displaying SVG icons
 * @remarks
 * This component renders SVG icons from the SvgIconService registry.
 * It supports different icon types and sizes, with color customization.
 *
 * @example
 * ```html
 * <svg-icon [icon]="'search'" class="custom-class"></svg-icon>
 * ```
 */
declare class SvgIconComponent implements OnInit {
    svgIconS: SvgIconService;
    /**
     * The type of icon to display
     * @remarks
     * Must be one of the predefined icon types from SVGIconType
     */
    class: string;
    /**
     * Configuration for the icon's appearance
     * @remarks
     * Controls the default and hover colors of the icon
     */
    config: {
        color: string;
        onhover: string;
    };
    /**
     * The icon name to display
     * @remarks
     * When set, it fetches the SVG from the service and applies color configuration
     */
    icon: string;
    /**
     * The icon name input setter
     * @remarks
     * Processes the icon name, applies color configuration, and triggers rendering
     */
    set _icon(v: string);
    iconRef: ElementRef<HTMLSpanElement>;
    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>;
}

/**
 * A button loader component that displays loading state and content.
 * Uses OnPush change detection strategy for better performance.
 */
declare class BtnLoaderComponent {
    /** Flag to indicate if the loader should be displayed in mini size */
    readonly mini: _angular_core.InputSignal<boolean>;
    /** Flag to control the loading state of the button */
    readonly loading: _angular_core.InputSignal<boolean>;
    /** Required template reference for the button's content */
    readonly btnContentTemplateRef: _angular_core.InputSignal<TemplateRef<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnLoaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BtnLoaderComponent, "lib-btn-loader", never, { "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "btnContentTemplateRef": { "alias": "btnContentTemplateRef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Interface defining the configuration options for buttons
 * @example
 * ```typescript
 * const config: IBtnConfig = {
 *   iconComponentType: 'svg-icon',
 *   iconSize: '24px',
 *   defaultType: 'primary',
 *   iconPosition: 'left',
 *   loaderComponent: CustomLoaderComponent
 * };
 * ```
 */
interface IBtnConfig {
    /** Type of icon component to use ('svg-icon' or 'icon') */
    iconComponentType?: 'svg-icon' | 'icon';
    /** Size of the icon in CSS units */
    iconSize?: string;
    /** Default button type to use when not specified */
    defaultType?: BtnType;
    /** Position of the icon relative to the button text */
    iconPosition?: IBtnIconPosition;
    /** Custom loader component to use for loading states */
    loaderComponent?: Type<BtnLoaderComponent>;
}
/**
 * Type defining possible positions for button icons
 * @example
 * ```typescript
 * const position: IBtnIconPosition = 'left'; // or 'right'
 * ```
 */
type IBtnIconPosition = 'left' | 'right';

/**
 * Service that provides button configuration and styling functionality
 * @remarks
 * This service manages button configurations, styles, and icon handling for the button components
 */
declare class BtnService {
    /**
     * Mapping of button types to their corresponding CSS classes
     * @example
     * ```typescript
     * btnClasses = {
     *   primary: 'btn btn-primary w-100',
     *   secondary: 'btn btn-secondary w-100'
     * }
     * ```
     */
    btnClasses: {
        [x in BtnType]?: string;
    };
    /**
     * Protected signal holding the current button configuration
     */
    protected readonly _config: _angular_core.WritableSignal<IBtnConfig>;
    /**
     * Computed property that provides a read-only copy of the current configuration
     */
    readonly config: _angular_core.Signal<{
        iconComponentType?: "svg-icon" | "icon";
        iconSize?: string;
        defaultType?: BtnType;
        iconPosition?: IBtnIconPosition;
        loaderComponent?: _angular_core.Type<BtnLoaderComponent>;
    }>;
    constructor();
    /**
     * Updates the button configuration with new values
     * @param config - Partial configuration object to merge with existing config
     * @example
     * ```typescript
     * btnService.updateConfig({ defaultType: 'primary' });
     * ```
     */
    updateConfig(config: Partial<IBtnConfig>): void;
    /**
     * Gets the icon configuration based on the icon type
     * @param iconType - The type of icon to get configuration for
     * @returns Object containing icon details including icon string and position
     * @example
     * ```typescript
     * const iconConfig = btnService.getIcon('calendar');
     * // Returns: { icon: null, iconPosition: 'left', iconString: 'fas fa-calendar-alt' }
     * ```
     */
    getIcon: (iconType: IconType) => {
        icon: any;
        iconPosition: string;
        iconString: any;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BtnService>;
}

/**
 * Interface defining available icon names
 * @remarks
 * This interface maps icon names to their string representations.
 * It serves as a type-safe way to reference icons throughout the application.
 */
interface IconNames {
    /** Home icon */
    home?: string;
    /** Search icon */
    search?: string;
}
/**
 * Type representing valid icon names
 * @remarks
 * This type is derived from the keys of the IconNames interface.
 * It ensures type safety when referencing icons in the application.
 */
type EIcon = keyof IconNames;

/**
 * Button component that provides various styling options and functionality
 * for creating different types of buttons in the application.
 */
declare class BtnComponent implements OnInit {
    readonly btnS: BtnService;
    /** Form schema to check for specific invalid form fields */
    formSchema: IFormSchema[];
    /** Indicates if the form is invalid */
    formIsInvalid: boolean;
    /** Type of icon component to use */
    readonly iconComponentType: _angular_core.InputSignal<"icon" | "svg-icon">;
    /** Size of the icon */
    readonly iconSize: _angular_core.InputSignal<string>;
    readonly matIcon: _angular_core.InputSignal<string>;
    /** Component to use for the loader */
    readonly loaderComponent: _angular_core.InputSignal<Type<BtnLoaderComponent>>;
    /**
     * Sets the icon for the button
     * @param v Icon type to display
     */
    set _icon(v: SVGIconType | EIcon | 'edit' | 'more');
    /** Button type (primary, outline, etc.) */
    readonly type: _angular_core.ModelSignal<BtnType>;
    /**
     * Sets the button group which applies predefined styling and icons
     * @param v Button group type
     */
    set _group(v: BtnGroup);
    /** Computed CSS class based on button type */
    protected readonly _mclass: _angular_core.Signal<string>;
    /** HTML button type attribute */
    actionType: 'submit' | 'button' | 'reset';
    /** Whether to apply animation to the button */
    animate: boolean;
    /** Badge text or number to display on the button */
    badge: string | number;
    /** Additional CSS classes */
    class: string;
    /** Custom icon string (e.g., font awesome classes) */
    readonly customIcon: _angular_core.ModelSignal<string>;
    /** Whether the button is disabled */
    disabled: boolean;
    /** Form to associate with the button */
    form: FormGroup | FormControl | FormArray;
    /** Help text for tooltip */
    help: string;
    /** Input for explicitly setting icon-only button */
    readonly _iconBtn: _angular_core.InputSignal<boolean>;
    /** Computed property to determine if button is icon-only */
    protected readonly iconBtn: _angular_core.Signal<boolean>;
    /** Whether to use lite styling */
    lite: boolean;
    /** Loading state model */
    readonly _loading: _angular_core.ModelSignal<boolean>;
    /**
     * Sets the loading state
     * @param v Loading state value
     */
    set loading(v: boolean);
    /**
     * Gets the current loading state
     * @returns Current loading state
     */
    get loading(): boolean;
    /** CSS class model */
    readonly mclass: _angular_core.ModelSignal<string>;
    /** Whether to show the help icon */
    showHelpIcon: boolean;
    /** Whether to use mini styling */
    readonly mini: _angular_core.ModelSignal<boolean>;
    /** Button text */
    readonly text: _angular_core.ModelSignal<string>;
    /** Whether the button is valid */
    valid: boolean;
    /** Sub-buttons for dropdown menus */
    subButtons: IBtn[];
    /** Behavior when form is invalid */
    onFormInvalid: keyof typeof OnFormInvalid;
    /** Click event emitter */
    mclick: EventEmitter<any>;
    /** Icon signal */
    protected readonly icon: _angular_core.WritableSignal<any>;
    /** Position of the icon relative to text */
    readonly iconPosition: _angular_core.ModelSignal<IBtnIconPosition>;
    /** Change detector reference */
    protected readonly cdr: ChangeDetectorRef;
    /** Computed inputs for the loader component */
    protected readonly loaderInputs: _angular_core.Signal<{
        readonly mini?: boolean | _angular_core.InputSignal<boolean>;
        readonly loading?: boolean | _angular_core.InputSignal<boolean>;
        readonly btnContentTemplateRef?: TemplateRef<any> | _angular_core.InputSignal<TemplateRef<any>>;
    }>;
    /** Reference to button content template */
    protected readonly btnContentTemplateRef: _angular_core.Signal<TemplateRef<any>>;
    /**
     * Initializes the component and sets up form validation subscription
     */
    ngOnInit(): void;
    /**
     * Checks form validity and marks all fields as touched if button is disabled
     */
    checkForm(): void;
    /**
     * Handles button click events
     * @param $event Click event
     */
    click($event?: any): void;
    /**
     * Determines if the button should be disabled
     * @returns True if button should be disabled
     */
    get isDisabled(): boolean;
    /**
     * Set loader state
     * @param value Loader state
     */
    setLoader(value: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BtnComponent, "app-btn,btn", never, { "formSchema": { "alias": "formSchema"; "required": false; }; "iconComponentType": { "alias": "iconComponentType"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "matIcon": { "alias": "matIcon"; "required": false; "isSignal": true; }; "loaderComponent": { "alias": "loaderComponent"; "required": false; "isSignal": true; }; "_icon": { "alias": "icon"; "required": false; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "_group": { "alias": "group"; "required": false; }; "actionType": { "alias": "actionType"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "class": { "alias": "class"; "required": false; }; "customIcon": { "alias": "customIcon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "form": { "alias": "form"; "required": false; }; "help": { "alias": "help"; "required": false; }; "_iconBtn": { "alias": "iconBtn"; "required": false; "isSignal": true; }; "lite": { "alias": "lite"; "required": false; }; "_loading": { "alias": "loading"; "required": false; "isSignal": true; }; "mclass": { "alias": "mclass"; "required": false; "isSignal": true; }; "showHelpIcon": { "alias": "showHelpIcon"; "required": false; }; "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; }; "subButtons": { "alias": "subButtons"; "required": false; }; "onFormInvalid": { "alias": "onFormInvalid"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; }, { "type": "typeChange"; "customIcon": "customIconChange"; "_loading": "loadingChange"; "mclass": "mclassChange"; "mini": "miniChange"; "text": "textChange"; "mclick": "mclick"; "iconPosition": "iconPositionChange"; }, never, ["*"], true, never>;
}
/**
 * Enum defining behavior options when a form is invalid
 */
declare enum OnFormInvalid {
    disable = "disable",
    warn = "warn"
}

/**
 * Component for displaying an information icon with tooltip
 * @remarks
 * This component provides a simple way to display an information icon with a tooltip message.
 * It supports customization of icon color and positioning.
 */
declare class InfoIconComponent implements OnInit {
    /**
     * Tooltip text to display when hovering over the icon
     */
    text: string;
    /**
     * Whether to use colored icon (default: true)
     */
    coloured: boolean;
    /**
     * Whether to position the icon to the left (default: false)
     */
    left: boolean;
    /**
     * Whether to position the icon to the right (default: true)
     */
    right: boolean;
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfoIconComponent, "info-icon", never, { "text": { "alias": "text"; "required": false; }; "coloured": { "alias": "coloured"; "required": false; }; "left": { "alias": "left"; "required": false; }; "right": { "alias": "right"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Base input component providing common functionality for all input types
 * @remarks
 * This component serves as the base for all input components, providing common functionality
 * for form controls, validation, and UI interactions.
 *
 * @example
 * ```html
 * <app-input
 *   [type]="'text'"
 *   [label]="'Name'"
 *   [control]="nameControl"
 *   [required]="true"
 * ></app-input>
 * ```
 */
declare class InputBaseComponent {
    readonly showingCustomInput: _angular_core.WritableSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputBaseComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputBaseComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

/**
 * Base input component providing common functionality for all input types
 * @remarks
 * This component serves as the base for all input components, providing common functionality
 * for form controls, validation, and UI interactions.
 *
 * @example
 * ```html
 * <app-input
 *   [type]="'text'"
 *   [label]="'Name'"
 *   [control]="nameControl"
 *   [required]="true"
 * ></app-input>
 * ```
 */
declare class InputBasicComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any, TControl = string, TOption = any> extends InputBaseComponent implements OnInit {
    readonly iS: InputService;
    /** Accepted file types for file inputs */
    accept?: string;
    /** Whether to enable autocomplete */
    autocomplete?: boolean;
    /** Whether to automatically pick value field */
    autoPickValueField?: boolean;
    /** Whether to clear value when disabled */
    clearOnDisable?: boolean;
    /** Additional CSS classes */
    cls?: string;
    /** Whether to apply colored styling */
    colored?: boolean;
    /** Initial checked state for checkboxes */
    checked?: boolean;
    /** Context data for the input */
    contextData?: any;
    /** Whether this is a dashboard input */
    dashboardInput?: boolean;
    /** Whether debug mode is enabled */
    debug?: boolean;
    /** Number of decimal points for number inputs */
    decimalPoints?: number;
    /** Label to display at the end */
    endLabel?: string;
    /** Tooltip for end label */
    endLabelTooltip?: string;
    /** Form group containing the control */
    readonly form: _angular_core.ModelSignal<FormGroup<TFormGroup>>;
    /** Type of validation to apply */
    validationType?: EValidationType;
    /** Array of validation messages */
    validations?: IValidationMessage[];
    /** Whether to disable formatting */
    noFormat?: boolean;
    /** Whether to hide the input */
    hide?: boolean;
    /** Hint text to display */
    hint?: string;
    /** Icon to display */
    icon?: SVGIconType;
    /** Unique identifier for the input */
    id?: string;
    /** Input-specific CSS class */
    inpCl?: string;
    /** Field label */
    readonly label: _angular_core.InputSignal<string>;
    readonly allowCustomInput: _angular_core.InputSignal<boolean>;
    /** Link for the label */
    labelLink?: string;
    /** Field(s) to use for option labels */
    labelField?: keyof TOption | (keyof TOption)[];
    /** Type of label to use */
    labelType?: OptionLabelType;
    /** Label CSS class */
    lblCl?: string;
    /** Whether to use light theme */
    light?: boolean;
    /** Whether the input is in loading state */
    loading?: boolean;
    /** Maximum value for number inputs */
    max?: number;
    /** Minimum value for number inputs */
    min?: number;
    /** Whether to use mini size */
    mini?: boolean;
    /** Whether to allow multiple selections */
    multiple?: boolean;
    /** Name of the form control */
    readonly name: _angular_core.ModelSignal<keyof TFormGroup>;
    /** Function to format option display */
    optionFormatter?: (item: TOption) => string;
    /** Function to initialize options */
    optionsInitFunc?: () => Observable<TOption[]>;
    /** Placeholder text */
    readonly placeholder: _angular_core.InputSignal<string>;
    /** Prefix to display */
    prefix?: string;
    /** Start field for range inputs */
    startField?: string;
    /** End field for range inputs */
    endField?: string;
    /** Whether the input is readonly */
    readonly?: boolean;
    /** Whether the input is required */
    readonly required: _angular_core.InputSignal<boolean>;
    /** Whether to disable paste */
    noPaste?: boolean;
    /** Whether to show empty option */
    showEmptyOption?: boolean;
    /** Whether to show separate label */
    readonly showSeperateLabel: _angular_core.InputSignal<boolean>;
    /** Whether to show validation */
    readonly showValidation: _angular_core.InputSignal<boolean>;
    /** Whether to show validation message */
    showValidationMsg?: boolean;
    /** Whether to show validation icon */
    showValidationIcon?: boolean;
    /** Whether to use small size */
    small?: boolean;
    /** Whether to use stacked layout */
    stacked?: boolean;
    /** Suffix to display */
    suffix?: string;
    /** Input theme */
    theme?: InputTheme;
    /** Whether to translate options */
    translateOptions?: boolean;
    /** Field to use for option values */
    valueField?: keyof TOption;
    /** Custom validation messages */
    vms?: IValidationMessage[];
    /** Whether to use extra small size */
    xsmall: boolean;
    /** Event emitter for validity changes */
    readonly validityChecked: _angular_core.OutputEmitterRef<any>;
    /** Event emitter for option selection changes */
    readonly mSelectOptionChange: _angular_core.OutputEmitterRef<any>;
    /** Event emitter for context changes */
    readonly mContextChange: _angular_core.OutputEmitterRef<any>;
    /** Whether the input is disabled */
    disabled?: boolean;
    /** Array of options */
    readonly options: _angular_core.WritableSignal<IOption[]>;
    /** Raw options data */
    rawOptions?: any[];
    /** Whether to show password */
    showPassword?: boolean;
    /** Input type */
    readonly type: _angular_core.WritableSignal<InputType>;
    readonly customInputType: _angular_core.InputSignal<InputType>;
    /** Whether view is initialized */
    viewInited?: boolean;
    /** Whether value was force patched */
    forcePatched?: boolean;
    /** Currently selected option */
    selectionObject?: TOption;
    /** Original input type */
    readonly oType: _angular_core.WritableSignal<InputType>;
    /** Form field appearance */
    readonly appearance: _angular_core.InputSignal<MatFormFieldAppearance>;
    /** Whether to use Material label */
    readonly useMatLabel: _angular_core.InputSignal<boolean>;
    /**
     * Sets the validation type and retrieves corresponding messages
     * @param v - Validation type to set
     */
    set _validationKey(v: EValidationType);
    /**
     * Sets the disabled state of the control
     * @param v - Whether to disable the control
     */
    set _disabled(v: boolean);
    /**
     * Custom function to handle select changes
     * @param val - Selected value
     * @param options - Available options
     * @param rawOptions - Raw options data
     */
    customSelectChangeAction: (val: string | number, options: any[], rawOptions: any[]) => any;
    /**
     * Sets the options for the input
     * @param v - Array of options
     */
    set _options(v: TOption[]);
    /**
     * Sets the input type
     * @param v - Type of input
     */
    set _type(v: InputType);
    /** Internal value storage */
    __value: string | number;
    /** Sets the input value */
    set _value(v: string | number);
    /** Reference to the input element */
    inpTag: ElementRef<HTMLInputElement>;
    /** Array of image paths for file inputs */
    imagePaths?: string[];
    /** Computed placeholder value */
    protected cPlaceholder: _angular_core.Signal<string>;
    /** Computed name string */
    protected nameStr: _angular_core.Signal<string>;
    /** Computed form control */
    readonly control: _angular_core.Signal<FormControl<TControl>>;
    /** Observable of control property changes */
    readonly controlPropNotifierRes: _angular_core.ResourceRef<{
        control: FormControl<TControl>;
        event: _angular_forms.ControlEvent<TControl>;
    }>;
    /** Signal for control events */
    readonly controlEventChange: _angular_core.Signal<{
        control: FormControl<TControl>;
        event: _angular_forms.ControlEvent<TControl>;
    }>;
    /** Output for value changes */
    readonly mchange: _angular_core.OutputEmitterRef<TControl>;
    /** Computed value for Material label usage */
    readonly cUseMatLabel: _angular_core.Signal<boolean>;
    /** Computed value for custom label usage */
    readonly cUseCustomLabel: _angular_core.Signal<boolean>;
    readonly dateInputComponent: _angular_core.Signal<DateInputComponent>;
    readonly allowCustomInputEffect: _angular_core.EffectRef;
    readonly showingCustomInputEffect: _angular_core.EffectRef;
    readonly valueEffect: _angular_core.EffectRef;
    /**
     * Initializes the component
     */
    ngOnInit(): void;
    /**
     * Called after view initialization
     */
    ngAfterViewInit(): void;
    toggleCustomInput(): void;
    /**
     * Disables the control if needed
     * @param control - Control to disable
     */
    disableControl(control?: AbstractControl): void;
    /** Computed value for required state */
    readonly isRequired: _angular_core.Signal<boolean>;
    /**
     * Handles input changes
     * @param e - Change event
     */
    change(e: any | MatCheckboxChange | MatSlideToggleChange): void;
    /** Computed value for valid state */
    readonly valid: _angular_core.Signal<boolean>;
    /** Computed value for invalid state */
    readonly invalid: _angular_core.Signal<boolean>;
    /** Computed value for dirty state */
    readonly dirty: _angular_core.Signal<boolean>;
    /** Computed value for pending state */
    readonly pending: _angular_core.Signal<boolean>;
    /** Computed value for current value */
    readonly value: _angular_core.Signal<TControl>;
    /** Computed value for whether the input has a value */
    readonly hasValue: _angular_core.Signal<boolean>;
    /** Computed value for invalid checkbox state */
    readonly invalidCheckbox: _angular_core.Signal<boolean>;
    /**
     * Handles file upload
     * @param e - File input event
     */
    upload(e: any): void;
    /**
     * Gets the label for file input
     * @param value - Current value
     * @returns Formatted label
     */
    fileInputLabel: (value: any) => string;
    /**
     * Logs the current form state
     */
    log(): void;
    /**
     * Handles date changes
     * @param value - New date value
     */
    dateChanged(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputBasicComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputBasicComponent<any, any, any>, "app-input", never, { "accept": { "alias": "accept"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "autoPickValueField": { "alias": "autoPickValueField"; "required": false; }; "clearOnDisable": { "alias": "clearOnDisable"; "required": false; }; "cls": { "alias": "cls"; "required": false; }; "colored": { "alias": "colored"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "contextData": { "alias": "contextData"; "required": false; }; "dashboardInput": { "alias": "dashboardInput"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "decimalPoints": { "alias": "decimalPoints"; "required": false; }; "endLabel": { "alias": "endLabel"; "required": false; }; "endLabelTooltip": { "alias": "endLabelTooltip"; "required": false; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "noFormat": { "alias": "noFormat"; "required": false; }; "hide": { "alias": "hide"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "id": { "alias": "id"; "required": false; }; "inpCl": { "alias": "inpCl"; "required": false; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "allowCustomInput": { "alias": "allowCustomInput"; "required": false; "isSignal": true; }; "labelLink": { "alias": "labelLink"; "required": false; }; "labelField": { "alias": "labelField"; "required": false; }; "labelType": { "alias": "labelType"; "required": false; }; "lblCl": { "alias": "lblCl"; "required": false; }; "light": { "alias": "light"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "mini": { "alias": "mini"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "optionFormatter": { "alias": "optionFormatter"; "required": false; }; "optionsInitFunc": { "alias": "optionsInitFunc"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; }; "startField": { "alias": "startField"; "required": false; }; "endField": { "alias": "endField"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "noPaste": { "alias": "noPaste"; "required": false; }; "showEmptyOption": { "alias": "showEmptyOption"; "required": false; }; "showSeperateLabel": { "alias": "showSeperateLabel"; "required": false; "isSignal": true; }; "showValidation": { "alias": "showValidation"; "required": false; "isSignal": true; }; "showValidationMsg": { "alias": "showValidationMsg"; "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; }; "translateOptions": { "alias": "translateOptions"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "vms": { "alias": "vms"; "required": false; }; "xsmall": { "alias": "xsmall"; "required": false; }; "customInputType": { "alias": "customInputType"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "useMatLabel": { "alias": "useMatLabel"; "required": false; "isSignal": true; }; "_validationKey": { "alias": "validationKey"; "required": false; }; "_disabled": { "alias": "disabled"; "required": false; }; "customSelectChangeAction": { "alias": "customSelectChangeAction"; "required": false; }; "_options": { "alias": "options"; "required": false; }; "_type": { "alias": "type"; "required": false; }; "_value": { "alias": "mvalue"; "required": false; }; }, { "form": "formChange"; "name": "nameChange"; "validityChecked": "validityChecked"; "mSelectOptionChange": "mSelectOptionChange"; "mContextChange": "mContextChange"; "mchange": "mchange"; }, never, never, true, never>;
}
/** Type for input themes */
type InputTheme = 1 | 2;
/** Type for option label types */
type OptionLabelType = 'bnk' | 'ccd' | 'cd' | 'cdt' | 'cf' | 'cmd' | 'cn' | 'ct' | 'gd' | 'ha' | 'id' | 'if' | 'ifl' | 'it' | 'md' | 'pd' | 'nf' | 'td' | 'title' | 'ud' | 'uf' | 'vl' | 'vv';
/** Interface for option objects */
interface IOption {
    value: any;
    label: string;
}

/**
 * Component for displaying response messages with status indicators
 * @remarks
 * This component provides a visual representation of response messages with success/failure states
 * and the ability to reset the status. It can be used to show operation results, form submissions,
 * or any other status-based feedback.
 *
 * @example
 * ```html
 * <response-card
 *   header="Operation Status"
 *   [showResponse]="true"
 *   [status]="1">
 * </response-card>
 * ```
 */
declare class ResponseCardComponent {
    /**
     * Header text to display in the card
     */
    header: string;
    /**
     * Whether to show the response content
     * @default false
     */
    showResponse: boolean;
    /**
     * Status of the response
     * @remarks
     * - 1: Success state
     * - 0: Failure state
     * @default 1
     */
    status: 1 | 0;
    /**
     * Resets the status and hides the response
     * @remarks
     * This method sets the status to null and hides the response content
     */
    resetStatus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponseCardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResponseCardComponent, "response-card", never, { "header": { "alias": "header"; "required": false; }; "showResponse": { "alias": "showResponse"; "required": false; }; "status": { "alias": "status"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Component for displaying feedback messages with different status types
 * @remarks
 * This component displays feedback messages with different status types (error, success, info).
 * It supports automatic scrolling to the message when displayed.
 *
 * @example
 * ```html
 * <feedback-card
 *   [message]="'Operation successful'"
 *   [status]="1">
 * </feedback-card>
 * ```
 */
declare class FeedbackCardComponent {
    /**
     * CSS classes to apply to the feedback card
     */
    readonly class: _angular_core.ModelSignal<string>;
    /**
     * The message to display
     */
    readonly message: _angular_core.ModelSignal<string>;
    /**
     * Default status value
     * @remarks
     * 0 - indicates error
     * 1 - indicates success
     * 2 - indicates info
     */
    private defaultStatus;
    /**
     * The status of the feedback message
     * @remarks
     * 0 - indicates error
     * 1 - indicates success
     * 2 - indicates info
     */
    readonly status: _angular_core.ModelSignal<0 | 1 | 2>;
    /**
     * Reference to the feedback card element
     */
    elRef: ElementRef<HTMLDivElement>;
    constructor();
    /**
     * Resets the feedback card to its default state
     * @remarks
     * Clears the message and resets the status to default
     */
    reset(): void;
    /**
     * Sets an error message
     * @param message - The error message to display
     * @remarks
     * If message is not a string, it will be logged to console
     * Automatically scrolls the feedback card into view
     */
    setErrorMessage(message: string | unknown): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeedbackCardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FeedbackCardComponent, "feedback-card", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, { "class": "classChange"; "message": "messageChange"; "status": "statusChange"; }, never, never, true, never>;
}

/**
 * Lightweight form schema interface
 * @remarks
 * This interface defines the basic structure for form field configuration
 * with support for various input types, validation, and options.
 *
 * @example
 * ```typescript
 * const schema: IFormSchemaLite = {
 *   field: 'username',
 *   type: 'text',
 *   label: 'Username',
 *   required: true
 * };
 * ```
 */
interface IFormSchemaLite<TFormGroup = any, TOption = any, TValue = any> {
    /**
     * Accepted file types for file inputs
     */
    accept?: string;
    /**
     * Asynchronous validators for the field
     */
    asyncValidators?: ((control: any) => Promise<any> | Observable<any>)[];
    /**
     * Whether to automatically pick value field from options
     */
    autoPickValueField?: boolean;
    /**
     * Whether the checkbox is checked
     */
    checked?: boolean;
    allowCustomInput?: boolean;
    customInputType?: InputType;
    /**
     * Whether to clear value when disabled
     */
    clearOnDisable?: boolean;
    /**
     * CSS classes to apply
     */
    cls?: string;
    /**
     * 3-letter country code
     */
    countryCode3?: string;
    /**
     * Number of decimal points for number inputs
     */
    decimalPoints?: number;
    /**
     * Whether the field is disabled
     */
    disabled?: boolean;
    /**
     * Whether to enable debug mode
     */
    debug?: boolean;
    /**
     * Function to determine if field should be disabled
     */
    disabledIf?: (row: TValue, cellField?: keyof TFormGroup) => boolean;
    /**
     * End field for range inputs
     */
    endField?: string;
    /**
     * Custom error message
     */
    errorMessage?: string;
    /**
     * Field name/key
     */
    field: keyof TFormGroup;
    /**
     * Key to get country code
     */
    getCountryCode3Key?: string;
    /**
     * Whether the field is hidden
     */
    hidden?: boolean;
    /**
     * Function to determine if field should be hidden
     */
    hideIfFunc?: (row: TValue) => boolean;
    /**
     * Help text/hint
     */
    hint?: string;
    /**
     * Icon to display
     */
    icon?: SVGIconType;
    /**
     * Field ID
     */
    id?: string;
    /**
     * Initial data value
     */
    initData?: any;
    /**
     * Whether this is a search field
     */
    isSearchField?: boolean;
    /**
     * Whether to ignore this field
     */
    ignore?: boolean;
    /**
     * Field label
     */
    label?: string;
    /**
     * Field(s) to use as label in options
     */
    labelField?: keyof TOption | (keyof TOption)[];
    /**
     * Maximum value
     */
    max?: number;
    /**
     * Minimum value
     */
    min?: number;
    /**
     * Whether multiple values are allowed
     */
    multiple?: boolean;
    /**
     * Next field to focus
     */
    nextField?: keyof TFormGroup;
    /**
     * Whether to disable formatting
     */
    noFormat?: boolean;
    /**
     * Whether the field is readonly
     */
    readonly?: boolean;
    /**
     * Whether to disable paste
     */
    noPaste?: boolean;
    /**
     * Function to call on value change
     */
    onChangeFunc?: (row: TValue, cellField?: keyof TFormGroup, _this?: any) => any;
    /**
     * Function to format option display
     */
    optionFormatter?: (item: TOption) => string;
    /**
     * Available options for select/autocomplete
     */
    options?: TOption[];
    /**
     * Asynchronous options source
     */
    optionsAsync?: Observable<TOption[]> | Promise<TOption[]>;
    /**
     * Function to get options
     */
    optionsFunc?: (row: any, cellField?: keyof TFormGroup) => Promise<any[]> | Observable<any[]>;
    /**
     * Function to filter options
     */
    filterFunc?: (query: string, options?: IOption[]) => Observable<any[]>;
    /**
     * Function to initialize options
     */
    optionsInitFunc?: () => Observable<TOption[]>;
    /**
     * Key to get options
     */
    optionsKey?: string;
    /**
     * Field order
     */
    order?: string;
    /**
     * Placeholder text
     */
    placeholder?: string;
    /**
     * Prefix to display
     */
    prefix?: string;
    /**
     * Whether the field is required
     */
    required?: boolean;
    /**
     * Function to perform search
     */
    searchFunc?: (...args: any[]) => any;
    /**
     * Whether to set as country code
     */
    setAsCountryCode3?: boolean;
    /**
     * Whether to show empty option
     */
    showEmptyOption?: boolean;
    /**
     * Whether to show separate label
     */
    showSeperateLabel?: boolean;
    /**
     * Whether to show validation
     */
    showValidation?: boolean;
    /**
     * Whether to show validation icon
     */
    showValidationIcon?: boolean;
    /**
     * Whether to show validation message
     */
    showValidationMsg?: boolean;
    /**
     * Start field for range inputs
     */
    startField?: string;
    /**
     * Sub-fields for nested forms
     */
    sub?: IFormSchemaLite[];
    /**
     * Template value
     */
    templateValue?: any;
    /**
     * Input type
     */
    type?: InputType;
    /**
     * Original input type
     */
    oType?: InputType;
    /**
     * Synchronous validators
     */
    validators?: ((control: any) => any)[];
    /**
     * Field value
     */
    value?: any;
    /**
     * Field to use as value in options
     */
    valueField?: keyof TOption;
}
/**
 * Interface for form options
 */
interface IFormOptions$1 {
    [field: string]: any;
}

/**
 * Service for managing form generator configuration
 * @remarks
 * This service provides configuration management for the form generator component,
 * including settings for toast notifications, response cards, and checkbox behavior.
 *
 * @example
 * ```typescript
 * constructor(private formGeneratorService: FormGeneratorService) {
 *   this.formGeneratorService.updateConfig({
 *     useToastNotifier: true,
 *     checkboxToList: true
 *   });
 * }
 * ```
 */
declare class FormGeneratorService {
    /**
     * Signal containing the current configuration
     */
    protected readonly _config: _angular_core.WritableSignal<IConfig$1>;
    /**
     * Computed value of the current configuration
     */
    readonly config: _angular_core.Signal<IConfig$1>;
    constructor();
    /**
     * Updates the configuration with new values
     * @param val - Partial configuration object with new values
     */
    updateConfig(val: Partial<IConfig$1>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormGeneratorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FormGeneratorService>;
}
/**
 * Interface for form generator configuration
 */
type IConfig$1 = {
    /**
     * Whether to use toast notifications
     */
    useToastNotifier?: boolean;
    /**
     * Whether to notify response card on submission
     */
    notifyResponseCardOnSubmission?: boolean;
    /**
     * Whether to convert checkboxes to list
     */
    checkboxToList?: boolean;
};

/**
 * Component for generating dynamic forms
 * @remarks
 * This component provides functionality to generate forms dynamically based on a schema.
 * It supports various input types, validation, nested forms, and submission handling.
 *
 * @example
 * ```html
 * <form-generator
 *   [formSchema]="schema"
 *   [form]="formGroup"
 *   (onSubmit)="handleSubmit($event)">
 * </form-generator>
 * ```
 */
declare class FormGeneratorComponent<TForm extends {
    [x in keyof TForm]: FormControl;
} = any> implements OnInit {
    uS: UtilityService;
    /**
     * Field to use as key in schema
     */
    keyField: 'field' | 'label';
    /**
     * Event emitted on form submission
     */
    readonly onSubmit: _angular_core.OutputEmitterRef<any>;
    /**
     * Event emitted when form values change
     */
    readonly formValueChanges: _angular_core.OutputEmitterRef<{ [x in keyof TForm]: any; }>;
    /**
     * Event emitted with submission response
     */
    _submissionResponse: EventEmitter<any>;
    /**
     * Function to handle form submission
     */
    submitFunc: (value: any, _this: FormGeneratorComponent<TForm>) => Promise<any>;
    /**
     * Text for submit button
     */
    submitBtnText: string;
    /**
     * Text to show on successful submission
     */
    submitSuccessText: string;
    /**
     * Whether to show submit button
     */
    readonly showSubmitBtn: _angular_core.InputSignal<boolean>;
    /**
     * Custom templates for form fields
     */
    readonly customTemplates: _angular_core.InputSignal<{ [k in keyof TForm]: TemplateRef<any>; }>;
    /**
     * Extra template to display in form
     */
    readonly extraFormTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /**
     * Whether to show the form
     */
    readonly isShow: _angular_core.InputSignal<boolean>;
    /**
     * Initial data to patch into form
     */
    initPatchData: {
        [x in keyof TForm]: any;
    };
    /**
     * Reference to feedback card component
     */
    readonly feedbackCardRef: Signal<FeedbackCardComponent>;
    /**
     * Grid style for form layout
     */
    gridStyle: number | 'auto';
    /**
     * Medium screen grid style
     */
    gridMDStyle: number | 'auto';
    /**
     * Large screen grid style
     */
    gridLGStyle: number | 'auto';
    /**
     * Extra large screen grid style
     */
    gridXXLStyle: number | 'auto';
    /**
     * Setter for grid style
     */
    set _gridStyle(v: number | 'auto');
    /**
     * Setter for medium screen grid style
     */
    set _gridMDStyle(v: number | 'auto');
    /**
     * Setter for large screen grid style
     */
    set _gridLGStyle(v: number | 'auto');
    /**
     * Setter for extra large screen grid style
     */
    set _gridXXLStyle(v: number | 'auto');
    /**
     * Whether to use loader
     */
    useLoader: boolean;
    /**
     * Loading state
     */
    readonly loading: _angular_core.ModelSignal<boolean>;
    /**
     * Whether to show separate labels
     */
    readonly showSeparateLabels: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show validation messages
     */
    readonly showValidationMsg: _angular_core.InputSignal<boolean>;
    /**
     * Whether form has response
     */
    readonly hasResponse: _angular_core.ModelSignal<boolean>;
    /**
     * Whether to hide after submission response
     */
    readonly hideAfterSubmissionResponse: _angular_core.ModelSignal<boolean>;
    /**
     * Whether to hide response card
     */
    readonly hideResponseCard: _angular_core.InputSignal<boolean>;
    /**
     * Response header text
     */
    responseHeader: string;
    /**
     * Form group for fields
     */
    form: FormGroup;
    /**
     * Setter for sample form
     */
    set sampleForm(v: FormGroup<TForm>);
    /**
     * Form group or controls to check for validity before submission
     */
    submitForm: FormGroup | FormControl;
    /**
     * Form schema signal
     */
    readonly formSchema: _angular_core.WritableSignal<IFormSchema<TForm, any, any>[]>;
    /**
     * Submission response
     */
    submissionResponse: any;
    /**
     * Setter for form schema
     */
    set _formSchema(v: IFormSchema<TForm>[]);
    /**
     * Options map
     */
    optionsMap: IFormOptions;
    /**
     * Country code map
     */
    cellCountryCode3s: IFormOptions;
    /**
     * Error message signal
     */
    readonly errorMessage: _angular_core.WritableSignal<string>;
    /**
     * Injected form generator service
     */
    protected service: FormGeneratorService;
    /**
     * Injected change detector
     */
    protected cdr: ChangeDetectorRef;
    ngOnInit(): void;
    /**
     * Emits form value changes
     */
    emitFormChanges(): void;
    /**
     * Initializes form with schema
     * @param schema - Form schema to initialize with
     */
    init(schema: IFormSchema[]): void;
    ngAfterViewInit(): void;
    /**
     * Formats grid styles
     */
    formatGridStyles(): void;
    /**
     * Amends form scheme
     * @param fieldName - Name of field to amend
     * @param formScheme - New scheme values
     */
    amendFormScheme(fieldName: keyof TForm, formScheme: Partial<IFormSchema<TForm>>): void;
    /**
     * Handles field value changes
     * @param field - Field that changed
     * @param inp - Input component instance
     */
    onChange(field: IFormSchema, inp: InputBasicComponent): void;
    /**
     * Adds item to form array
     * @param scheme - Form scheme
     * @param data - Optional data to initialize with
     */
    addItem(scheme: IFormSchema<TForm>, data?: any): void;
    /**
     * Removes item from form array
     * @param index - Index of item to remove
     * @param formName - Name of form array
     */
    removeItem(index: number, formName: string | number | symbol): void;
    /**
     * Submits form
     * @param rc - Response card component
     */
    submit(rc: ResponseCardComponent): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormGeneratorComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormGeneratorComponent<any>, "form-generator", never, { "keyField": { "alias": "keyField"; "required": false; }; "submitFunc": { "alias": "submitFunc"; "required": false; }; "submitBtnText": { "alias": "submitBtnText"; "required": false; }; "submitSuccessText": { "alias": "submitSuccessText"; "required": false; }; "showSubmitBtn": { "alias": "showSubmitBtn"; "required": false; "isSignal": true; }; "customTemplates": { "alias": "customTemplates"; "required": false; "isSignal": true; }; "extraFormTemplate": { "alias": "extraFormTemplate"; "required": false; "isSignal": true; }; "isShow": { "alias": "isShow"; "required": false; "isSignal": true; }; "initPatchData": { "alias": "initPatchData"; "required": false; }; "_gridStyle": { "alias": "gridStyle"; "required": false; }; "_gridMDStyle": { "alias": "gridMDStyle"; "required": false; }; "_gridLGStyle": { "alias": "gridLGStyle"; "required": false; }; "_gridXXLStyle": { "alias": "gridXXLStyle"; "required": false; }; "useLoader": { "alias": "useLoader"; "required": false; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "showSeparateLabels": { "alias": "showSeparateLabels"; "required": false; "isSignal": true; }; "showValidationMsg": { "alias": "showValidationMsg"; "required": false; "isSignal": true; }; "hasResponse": { "alias": "hasResponse"; "required": false; "isSignal": true; }; "hideAfterSubmissionResponse": { "alias": "hideAfterSubmissionResponse"; "required": false; "isSignal": true; }; "hideResponseCard": { "alias": "hideResponseCard"; "required": false; "isSignal": true; }; "responseHeader": { "alias": "responseHeader"; "required": false; }; "form": { "alias": "form"; "required": false; }; "sampleForm": { "alias": "sampleForm"; "required": false; }; "submitForm": { "alias": "submitForm"; "required": false; }; "_formSchema": { "alias": "formSchema"; "required": false; }; }, { "onSubmit": "onSubmit"; "formValueChanges": "formValueChanges"; "_submissionResponse": "submissionResponse"; "loading": "loadingChange"; "hasResponse": "hasResponseChange"; "hideAfterSubmissionResponse": "hideAfterSubmissionResponseChange"; }, never, ["[response]"], true, never>;
}
/**
 * Extended form schema interface
 */
interface IFormSchema<TFormGroup extends {
    [x in keyof TFormGroup]: FormControl;
} = any, TOption = any, TValue = any> extends IFormSchemaLite<TFormGroup, TOption, TValue> {
    /**
     * Form group for sub-fields
     */
    form?: FormGroup<any>;
    /**
     * Type of label to display
     */
    labelType?: OptionLabelType;
    /**
     * Function to call on value change
     */
    onChangeFunc?: (row: TValue, cellField?: keyof TFormGroup, _this?: FormGeneratorComponent<TFormGroup>, inp?: InputBasicComponent) => any;
    /**
     * Sub-fields for nested forms
     */
    sub?: IFormSchema[];
}
/**
 * Type for form schema with form controls
 */
type IFormSchema2<TItem> = IFormSchema<{
    [x in keyof TItem]: FormControl;
}>;
/**
 * Interface for form options
 */
interface IFormOptions {
    [field: string]: any;
}

/**
 * Service for handling reactive form input operations
 * Provides utilities for converting between form schemas and form controls
 * @template TIFormSchema - Type of form schema, defaults to IFormSchema
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Create a form from schema
 * const formSchema = [
 *   { field: 'name', value: '', validators: [Validators.required] },
 *   { field: 'email', value: '', validators: [Validators.email] }
 * ];
 *
 * const formControls = reactiveFormInputService.formSchemaToFormControls(formSchema);
 * const formGroup = new FormGroup(formControls);
 * ```
 */
declare class ReactiveFormInputService<TIFormSchema = IFormSchema> {
    /**
     * Creates a new instance of ReactiveFormInputService
     */
    constructor();
    /**
     * Converts an array of form field schemas to form controls
     * @template T - Type of form fields, defaults to TIFormSchema
     * @param formFields - Array of form field schemas
     * @returns Object containing form controls mapped by field names
     * @example
     * ```typescript
     * const fields = [
     *   { field: 'name', value: '', validators: [Validators.required] },
     *   { field: 'email', value: '', validators: [Validators.email] }
     * ];
     * const controls = service.formSchemaToFormControls(fields);
     *
     * // Resulting controls object:
     * // {
     * //   name: FormControl('', [Validators.required]),
     * //   email: FormControl('', [Validators.email])
     * // }
     * ```
     */
    formSchemaToFormControls<T = TIFormSchema>(formFields: T[]): {
        [key: string]: AbstractControl<any, any, any>;
    };
    /**
     * Creates form controls from a plain object
     * @param obj - Object containing field values
     * @returns Object containing form controls mapped by field names
     * @example
     * ```typescript
     * const obj = { name: 'John', email: 'john@example.com' };
     * const controls = service.formFieldsFromObj(obj);
     *
     * // Resulting controls object:
     * // {
     * //   name: FormControl('John'),
     * //   email: FormControl('john@example.com')
     * // }
     * ```
     */
    formFieldsFromObj(obj: any): {
        [key: string]: AbstractControl<any, any, any>;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReactiveFormInputService<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ReactiveFormInputService<any>>;
}

/**
 * Component for displaying information dialogs
 * @remarks
 * This component provides a reusable dialog for displaying information, warnings, or errors.
 * It supports different status types and custom button actions.
 */
declare class InfoDialogComponent implements OnInit {
    data: {
        text: string;
        heading: string;
        status: number;
        btns: IInfoDialogBtn[];
    };
    dialogRef: MatDialogRef<InfoDialogComponent, any>;
    ngOnInit(): void;
    /**
     * Handles the 'Yes' button click
     */
    yes(): void;
    /**
     * Handles the 'No' button click
     */
    no(): void;
    /**
     * Handles button actions
     * @param event - Pointer event
     * @param item - Button configuration
     */
    handleAction: (event: PointerEvent, item: IInfoDialogBtn) => void;
    /**
     * Gets CSS class based on status
     * @param status - Status number (0: danger, 1: success, 2: info, 3: warning)
     * @returns CSS class name
     */
    cls: (status?: 0 | 1 | 2 | 3) => "info" | "success" | "danger" | "" | "warning";
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoDialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfoDialogComponent, "info-dialog", never, {}, {}, never, never, true, never>;
}
/**
 * Interface for info dialog buttons
 * @remarks
 * This interface extends IBtn to add dialog-specific button properties.
 */
interface IInfoDialogBtn extends IBtn {
    /**
     * Determine whether to close the info on clicking the button
     */
    closeBoxOnClick?: boolean;
}

/**
 * Service for managing info dialogs
 * @remarks
 * This service provides functionality to display information dialogs with various status types.
 * It supports custom buttons, messages, and configurations.
 */
declare class InfoDialogService {
    dialog: MatDialog;
    /**
     * Override configuration for dialog
     */
    overrideDialogConfig: MatDialogConfig;
    /**
     * Displays an info dialog
     * @param text - Message to display
     * @param status - Status type (0: error, 1: success, 2: info, 3: warning)
     * @param heading - Dialog heading
     * @param btns - Custom buttons to display
     * @param disableClose - Whether to disable closing the dialog
     * @returns Promise that resolves when dialog is closed
     */
    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>;
}

/**
 * Extended utility service that provides common functionality for the application.
 * Extends UtilityServiceLite with additional features for dialogs, notifications, and form handling.
 */
declare class UtilityService extends UtilityServiceLite {
    /**
     * Emits true if mobile
     */
    mobileQueryChanged: ReplaySubject<boolean>;
    /**
     * Indicates whether the current view is mobile
     */
    isMobile: boolean;
    /**
     * Application environment configuration
     */
    environment: herlhay_helpers.Environment;
    /**
     * Material Dialog service for opening dialogs
     */
    dialog: MatDialog;
    /**
     * Material SnackBar service for displaying notifications
     */
    snackBar: MatSnackBar;
    /**
     * Service for handling confirmation dialogs
     */
    confirmDialogService: ConfirmDialogService;
    /**
     * Service for handling reactive form inputs
     */
    inputService: ReactiveFormInputService<any>;
    /**
     * Service for page-related functionality
     */
    pageS: PageService;
    /**
     * Service for toast notifications
     */
    notificationService: ToastNotificationsService;
    /**
     * Service for information dialogs
     */
    infoDialogService: InfoDialogService;
    /**
     * Opens a dialog and subscribes to its afterClosed event
     * @param comp - The component to be loaded into the dialog
     * @param config - Configuration options for the dialog
     * @param valueCB - Callback function to handle the dialog result when a value is returned
     * @param noValueCB - Optional callback function to handle when no value is returned
     * @returns The dialog reference
     */
    dialogOpener: (comp: any, config: MatDialogConfig, valueCB: (r: any) => any, noValueCB?: any) => rxjs.Subscription;
    rxResourceErrorWrapper: <T>(obs: Observable<T>) => Observable<T>;
    resourceErrorWrapper: <T>(ps: Promise<T>) => Promise<any>;
    /**
     * Opens a dialog and returns the dialog reference
     * @param comp - The component to be loaded into the dialog
     * @param config - Configuration options for the dialog
     * @returns The dialog reference
     */
    dialogOpenerRef: (comp: any, config: MatDialogConfig) => _angular_material_dialog.MatDialogRef<unknown, any>;
    /**
     * Shorthand for the confirm dialog service's confirm method
     */
    confirm: (text: string) => Promise<boolean>;
    /**
     * Converts an object to form controls
     */
    objToFormControls: (obj: any) => {
        [key: string]: _angular_forms.AbstractControl<any, any, any>;
    };
    /**
     * Converts a form schema to form controls
     */
    formSchemaToFormControls: <T = any>(formFields: T[]) => {
        [key: string]: _angular_forms.AbstractControl<any, any, any>;
    };
    /**
     * Shorthand 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;
    };
    /**
     * Displays an information dialog
     * @param text - The text content to display
     * @param status - Optional status indicator (0: error, 1: success, 2: info)
     * @param heading - Optional dialog heading
     * @param btns - Optional custom buttons configuration
     * @param disableClose - Optional flag to disable closing the dialog
     * @returns Promise that resolves to a boolean indicating the dialog result
     */
    info: (text: string | unknown, status?: 0 | 2 | 1, heading?: string, btns?: IInfoDialogBtn[], disableClose?: boolean) => Promise<boolean>;
    /**
     * Displays a notification toast
     * @param message - The message to display
     * @param cls - Optional class/type of notification (0: error, 1: success, 2: info, 3: warning)
     * @param duration - Optional duration in milliseconds
     * @param title - Optional title for the notification
     * @param extraConfig - Optional additional configuration
     * @returns Object with closed observable
     */
    notify: (message: string, cls?: 0 | 1 | 2 | 3, duration?: number, title?: string, extraConfig?: {
        [x: string]: any;
    }) => {
        closed: rxjs.Subject<{
            manuallyClosed: boolean;
        }>;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UtilityService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UtilityService>;
}

/**
 * Service responsible for prompting users when new versions of the application are available.
 * This service listens for version updates and triggers user prompts when new versions are ready.
 */
declare class PromptUpdateService {
    uS: UtilityService;
    /**
     * Creates an instance of PromptUpdateService.
     * @param swUpdate - Service worker update service for version management
     * @param uS - Utility service for common operations
     */
    constructor();
    /**
     * Prompts the user about an available update.
     * @param reason - Optional reason for the update prompt
     * @example
     * ```typescript
     * promptUpdateService.prompter('New features available');
     * ```
     */
    prompter(reason?: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PromptUpdateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PromptUpdateService>;
}

/**
 * Service responsible for checking and managing application updates.
 * This service handles the periodic checking for new versions of the application
 * and coordinates the update process when new versions are available.
 */
declare class CheckForUpdateService {
    appRef: ApplicationRef;
    updates: SwUpdate;
    puS: PromptUpdateService;
    /**
     * Creates an instance of CheckForUpdateService.
     * @param appRef - Angular application reference for stability checks
     * @param updates - Service worker update service for version management
     * @param puS - Service for prompting users about available updates
     */
    constructor();
    /**
     * Initializes the update checking process with configurable intervals.
     * @param itvl - Optional interval in milliseconds for checking updates (defaults to 30 minutes)
     * @param cb - Optional callback function to execute when an update is found
     * @example
     * ```typescript
     * checkForUpdateService.init(3600000, () => {
     *   console.log('Update check completed');
     * });
     * ```
     */
    init(itvl?: number, cb?: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckForUpdateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CheckForUpdateService>;
}

/**
 * Service responsible for handling unrecoverable service worker states.
 * This service manages critical service worker errors that cannot be automatically recovered from,
 * typically requiring user intervention or application reload.
 */
declare class HandleUnrecoverableStateService {
    uS: UtilityService;
    puS: PromptUpdateService;
    /**
     * Creates an instance of HandleUnrecoverableStateService.
     * @param updates - Service worker update service for version management
     * @param uS - Utility service for common operations
     * @param puS - Service for prompting users about available updates
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HandleUnrecoverableStateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HandleUnrecoverableStateService>;
}

/**
 * Service responsible for logging service worker update events.
 * This service tracks and logs various stages of the update process including
 * version detection, readiness, and installation failures.
 */
declare class LogUpdateService {
    uS: UtilityService;
    /**
     * Creates an instance of LogUpdateService.
     * @param updates - Service worker update service for version management
     * @param uS - Utility service for common operations
     */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LogUpdateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LogUpdateService>;
}

/**
 * Service for handling SDK patching operations
 * Provides utilities for mapping and transforming SDK-related data
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Map table query parameters
 * const queryParams = patchSdkService.tableQueryMap({
 *   page: 1,
 *   sortByField: 'name',
 *   sortByDirection: 'asc',
 *   limit: 10
 * });
 * ```
 */
declare class PatchSdkService {
    /**
     * Creates a new instance of PatchSdkService
     */
    constructor();
    /**
     * Maps table query parameters to an object literal
     * Transforms pagination, sorting, and limit parameters into a standardized format
     * @param query - Query parameters for table operations
     * @param query.page - Page number for pagination (1-based index)
     * @param query.sortByField - Field name to sort the table by
     * @param query.sortByDirection - Sort direction ('asc' for ascending, 'desc' for descending)
     * @param query.limit - Number of items to display per page
     * @returns Mapped query parameters as an object literal
     * @example
     * ```typescript
     * // Map query parameters for a table
     * const mappedQuery = patchSdkService.tableQueryMap({
     *   page: 2,
     *   sortByField: 'createdAt',
     *   sortByDirection: 'desc',
     *   limit: 25
     * });
     *
     * // Result:
     * // {
     * //   page: 2,
     * //   sortByField: 'createdAt',
     * //   sortByDirection: 'desc',
     * //   limit: 25
     * // }
     * ```
     */
    tableQueryMap: (query: {
        page: number;
        sortByField: string;
        sortByDirection: string;
        limit: number;
    }) => IObjectLiteral;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PatchSdkService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PatchSdkService>;
}

/**
 * Service for managing page loading states using Angular signals
 * Provides functionality to track and control multiple loading states
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Start a loader
 * pageLoaderService.startPl();
 *
 * // Check loading state
 * const isLoading = pageLoaderService.isLoading();
 *
 * // Stop a loader
 * pageLoaderService.stopPl();
 *
 * // Subscribe to loading state changes
 * pageLoaderService.isLoading$.subscribe(isLoading => {
 *   console.log('Loading state changed:', isLoading);
 * });
 * ```
 */
declare class PageLoaderService {
    /**
     * Internal signal tracking active loaders
     * @private
     */
    protected readonly _pageLoaders: _angular_core.WritableSignal<1[]>;
    /**
     * Computed signal providing read-only access to page loaders
     * @returns Array of active loaders
     */
    readonly pageLoaders: _angular_core.Signal<1[]>;
    /**
     * Creates a new instance of PageLoaderService
     */
    constructor();
    /**
     * Computed signal indicating if any loaders are active
     * @returns true if any loaders are active, false otherwise
     */
    isLoading: _angular_core.Signal<boolean>;
    /**
     * Observable stream of loading state changes
     * @returns Observable that emits when loading state changes
     */
    isLoading$: rxjs.Observable<boolean>;
    /**
     * Starts one or more page loaders
     * @param value - Number of loaders to start (default: 1)
     * @returns The current number of active loaders
     * @example
     * ```typescript
     * // Start a single loader
     * const activeLoaders = pageLoaderService.startPl();
     *
     * // Start multiple loaders
     * const activeLoaders = pageLoaderService.startPl(3);
     * ```
     */
    startPl: (value?: number) => number;
    /**
     * Restarts the loader by stopping all loaders and starting a new one
     * @returns The current number of active loaders
     * @example
     * ```typescript
     * // Restart all loaders
     * const activeLoaders = pageLoaderService.restartPl();
     * ```
     */
    restartPl: () => number;
    /**
     * Stops one or more page loaders
     * @param value - Number of loaders to stop (default: 1)
     * @returns The current number of active loaders
     * @example
     * ```typescript
     * // Stop a single loader
     * const activeLoaders = pageLoaderService.stopPl();
     *
     * // Stop multiple loaders
     * const activeLoaders = pageLoaderService.stopPl(3);
     * ```
     */
    stopPl: (value?: number) => number;
    /**
     * Stops all active page loaders
     * @example
     * ```typescript
     * // Stop all loaders
     * pageLoaderService.stopAllPls();
     * ```
     */
    stopAllPls: () => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageLoaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageLoaderService>;
}

/**
 * Service that manages service worker updates and related functionality.
 * This service coordinates various aspects of service worker updates including
 * checking for updates, prompting users, logging update status, and handling unrecoverable states.
 */
declare class ServiceWorkerService {
    puS: PromptUpdateService;
    luS: LogUpdateService;
    huS: HandleUnrecoverableStateService;
    cfuS: CheckForUpdateService;
    uS: UtilityService;
    /**
     * Checks for available updates and handles the update process.
     * @param cb - Optional callback function to execute after update check completes
     * @example
     * ```typescript
     * serviceWorkerService.getUpdates(() => {
     *   console.log('Update check completed');
     * });
     * ```
     */
    getUpdates(cb?: any): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ServiceWorkerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ServiceWorkerService>;
}

/**
 * Service for integrating Tawk.io live chat functionality into the application
 * Manages the loading, initialization, and interaction with the Tawk.io widget
 * @Injectable Provided in root
 */
declare class TawkIoService {
    private rendererFactory;
    private _document;
    private LocalStorageService;
    /**
     * Flag indicating whether the Tawk.io script has been loaded
     */
    private loaded;
    /**
     * Subject that emits when the Tawk.io script has finished loading
     */
    private loadSubject;
    /**
     * Angular renderer instance for DOM manipulation
     */
    private renderer;
    /**
     * Creates a new instance of TawkIoService
     * Initializes the Tawk.io widget if propertyId is configured in environment
     * @param rendererFactory - Factory for creating renderer instances
     * @param _document - Document reference for DOM manipulation
     * @param LocalStorageService - Service for managing local storage
     */
    constructor();
    /**
     * Loads the Tawk.io script and initializes the widget
     * Creates and injects the script tag with the Tawk.io configuration
     * @private
     */
    private load;
    /**
     * Callback function executed when Tawk.io script is loaded
     * Updates the loaded flag and notifies subscribers
     * @private
     */
    private loadedEvent;
    /**
     * Updates the Tawk.io user information
     * @param user - User object containing firstname, surname, email, and id
     * @example
     * ```typescript
     * const user = {
     *   firstname: 'John',
     *   surname: 'Doe',
     *   email: 'john@example.com',
     *   id: '123'
     * };
     * tawkService.UpdateTawkUser(user);
     * ```
     */
    UpdateTawkUser(user: any): void;
    /**
     * Wrapper function that ensures Tawk.io is loaded before executing a callback
     * @param func - Callback function to execute after Tawk.io is loaded
     * @private
     */
    private loadedWrapper;
    /**
     * Expands or minimizes the chat window
     * @param show - If true, maximizes the chat window; if false, minimizes it
     * @example
     * ```typescript
     * // Maximize chat window
     * tawkService.ExpandChatWindow(true);
     *
     * // Minimize chat window
     * tawkService.ExpandChatWindow(false);
     * ```
     */
    ExpandChatWindow(show?: boolean): void;
    /**
     * Shows or hides the chat widget
     * @param show - If true, shows the widget; if false, hides it
     * @example
     * ```typescript
     * // Show chat widget
     * tawkService.SetChatVisibility(true);
     *
     * // Hide chat widget
     * tawkService.SetChatVisibility(false);
     * ```
     */
    SetChatVisibility(show?: boolean): void;
    /**
     * Updates the user attributes in Tawk.io
     * @param user - User object containing firstname, surname, email, and id
     * @private
     */
    private updateAtrributes;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TawkIoService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TawkIoService>;
}

/**
 * Service for managing WebSocket connections in the application
 * Provides functionality to create and manage Socket.IO connections
 * @Injectable Provided in root
 */
declare class WebsocketService {
    uS: UtilityService;
    /**
     * Collection of socket connections used by the application
     * @property coreEV - Core event socket connection, only created if WebSocket is enabled
     */
    readonly sockets: {
        coreEV: IRSocket;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WebsocketService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WebsocketService>;
}
/**
 * Class representing a Socket.IO connection with retry and event handling capabilities
 */
declare class IRSocket {
    /**
     * Gets the socket connection ID
     * @returns The socket ID if connected, undefined otherwise
     */
    get id(): string;
    /**
     * Gets the connection status of the socket
     * @returns true if socket is connected, false otherwise
     */
    get isConnected(): boolean;
    /**
     * Base route for the WebSocket connection
     */
    route: string;
    /**
     * Current number of connection retry attempts
     */
    retryCount: number;
    /**
     * Maximum number of retry attempts before giving up
     * @default 5
     */
    maxRetryCount: number;
    /**
     * Socket.IO client instance
     */
    socket: Socket;
    /**
     * Subject that emits connection error events
     */
    onConnectionError: ReplaySubject<unknown>;
    /**
     * Subject that emits disconnect events
     */
    onDisconnect: ReplaySubject<unknown>;
    /**
     * Map of event listeners indexed by path
     */
    listeners: {
        [path: string]: ReplaySubject<any>;
    };
    /**
     * Unique identifier for the socket connection
     */
    identifier: string;
    /**
     * Creates a new Socket.IO connection
     * @param basePath - Websocket URL prefix. Defaults to using the base API URL converted to WebSocket protocol
     * @param path - Path to the websocket to listen to
     */
    constructor(basePath?: string, path?: string);
    /**
     * Adds an event listener for a specific path
     * @template T - Type of data expected from the event
     * @param path - Event path to listen to
     * @param identifier - Optional identifier to append to the event path (defaults to this.identifier)
     * @returns ReplaySubject that emits event data, or null if no path provided
     * @example
     * ```typescript
     * interface ProgressEvent {
     *   percentage: number;
     *   status: boolean;
     *   id: string;
     * }
     * const listener = socket.addListener<ProgressEvent>('progress');
     * listener.subscribe(data => console.log(data.percentage));
     * ```
     */
    addListener<T = {
        percentage: number;
        status: boolean;
        id: string;
    }>(path: string, identifier?: string): ReplaySubject<T>;
    /**
     * Removes an event listener for a specific path
     * Completes the associated ReplaySubject and removes it from the listeners map
     * @param path - Event path to stop listening to
     */
    removeListener(path: string): void;
}

/**
 * Base service class providing common HTTP operations
 * Implements basic CRUD operations using ApiService
 * @Injectable Provided in root
 * @example
 * ```typescript
 * // Extend BaseService to create a specific service
 * @Injectable()
 * export class UserService extends BaseService {
 *   protected baseURL = '/users';
 *
 *   // Inherits all CRUD operations
 *   // Additional methods can be added as needed
 * }
 * ```
 */
declare class BaseService {
    /**
     * Injected ApiService instance for making HTTP requests
     * @protected
     */
    protected apiS: ApiService;
    /**
     * Base URL for all API requests from this service
     * @protected
     */
    protected baseURL: string;
    /**
     * Creates a new instance of BaseService
     */
    constructor();
    /**
     * Performs a POST request
     * @template T - Type of response data
     * @param data - Data to send in request body
     * @param path - Additional path to append to base URL
     * @returns Observable of the response
     * @example
     * ```typescript
     * // Create a new user
     * this.post<User>({ name: 'John' }, '/create');
     * ```
     */
    protected post<T>(data?: any, path?: string): rxjs.Observable<T>;
    /**
     * Performs a PUT request
     * @template T - Type of response data
     * @param data - Data to send in request body
     * @param path - Additional path to append to base URL
     * @returns Observable of the response
     * @example
     * ```typescript
     * // Update user with ID 1
     * this.put<User>({ name: 'John Doe' }, '/1');
     * ```
     */
    protected put<T>(data?: any, path?: string): rxjs.Observable<T>;
    /**
     * Performs a GET request
     * @template T - Type of response data
     * @param path - Additional path to append to base URL
     * @param query - Query parameters to include in request
     * @returns Observable of the response
     * @example
     * ```typescript
     * // Get user with ID 1
     * this.get<User>('/1');
     *
     * // Get users with query parameters
     * this.get<User[]>('', { page: 1, limit: 10 });
     * ```
     */
    protected get<T>(path?: string, query?: any): rxjs.Observable<T>;
    /**
     * Performs a DELETE request
     * @template T - Type of response data
     * @param path - Additional path to append to base URL
     * @param query - Query parameters to include in request body
     * @returns Observable of the response
     * @example
     * ```typescript
     * // Delete user with ID 1
     * this.delete<void>('/1');
     *
     * // Delete users with query parameters
     * this.delete<void>('', { ids: [1, 2, 3] });
     * ```
     */
    protected delete<T>(path?: string, query?: any): rxjs.Observable<any>;
    /**
     * Formats a route by removing trailing slash if present
     * @param route - Route to format
     * @returns Formatted route string
     * @example
     * ```typescript
     * // Format route
     * const formatted = this.formatRoute('/users/'); // Returns '/users'
     * ```
     */
    formatRoute: (route: string) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BaseService>;
}

/**
 * Namespace containing form-related utilities and configurations
 */
declare namespace Forms {
    /**
     * Class providing form control configurations and validation utilities
     */
    class ConfigForms {
        /**
         * Validates if two form fields match (e.g., password confirmation)
         * @param formGroup - The form group containing the fields
         * @param field1 - First field name (default: 'password')
         * @param field2 - Second field name (default: '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
         * @param field1 - First field name
         * @param field2 - Second field name
         * @returns null if fields match, { noMatch: true } if they don't
         */
        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
         * @param value - Initial value
         * @returns FormControl with email validation
         */
        email(required?: boolean, value?: string): FormControl<string>;
        /**
         * Creates a form control for name input with validation
         * @param required - Whether the field is required
         * @param minLength - Minimum length requirement
         * @param value - Initial value
         * @returns FormControl with name validation
         */
        name(required?: boolean, minLength?: number, value?: string): FormControl<string>;
        /**
         * Creates a form control for array input
         * @param required - Whether the field is required
         * @param value - Initial value
         * @returns FormControl for array input
         */
        array(required?: boolean, value?: any[]): FormControl<any[]>;
        /**
         * Creates a form control for boolean input
         * @param required - Whether the field is required
         * @param value - Initial value
         * @returns FormControl for boolean input
         */
        boolean(required?: boolean, value?: boolean): FormControl<boolean>;
        /**
         * Creates a form control for username input with validation
         * @param required - Whether the field is required
         * @param minLength - Minimum length requirement
         * @param maxLength - Maximum length requirement
         * @param value - Initial value
         * @returns FormControl with username validation
         */
        username(required?: boolean, minLength?: number, maxLength?: number, value?: string): FormControl<string>;
        /**
         * Creates a generic form control with custom validation
         * @template T - Type of the form control value
         * @param value - Initial value
         * @param validatorOrOpts - Validator function(s) or options
         * @param asyncValidator - Async validator function(s)
         * @returns FormControl with specified validation
         */
        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
         * @param value - Initial value
         * @param maxLength - Maximum length requirement
         * @returns FormControl with number validation
         */
        number(required?: boolean, value?: any, maxLength?: number): FormControl<any>;
        /**
         * Creates a form control for integer input with validation
         * @param required - Whether the field is required
         * @param value - Initial value
         * @param maxLength - Maximum length requirement
         * @returns FormControl with integer validation
         */
        integer(required?: boolean, value?: any, maxLength?: number): FormControl<any>;
        /**
         * Creates a form control for postal code input with validation
         * @param required - Whether the field is required
         * @param value - Initial value
         * @returns FormControl with postal code validation
         */
        postalCode(required?: boolean, value?: any): FormControl<any>;
        /**
         * Creates a form control for phone number input with validation
         * @param required - Whether the field is required
         * @param value - Initial value
         * @returns FormControl with phone number validation
         */
        phone(required?: boolean, value?: string): FormControl<string>;
        /**
         * Creates a form control with required and minimum length validation
         * @param length - Minimum length requirement
         * @param value - Initial value
         * @returns FormControl with required and minLength validation
         */
        requiredMinLength(length: number, value?: string): FormControl<string>;
        /**
         * Creates a form control with required, minimum and maximum length validation
         * @param min - Minimum length requirement
         * @param max - Maximum length requirement
         * @returns FormControl with required, minLength and maxLength validation
         */
        requiredMinMaxLength(min: number, max: number): FormControl<string>;
        /**
         * Creates a form control with required validation
         * @param value - Initial value
         * @returns FormControl with required validation
         */
        required(value?: any): FormControl<any>;
        /**
         * Creates a form control with minimum length validation
         * @param length - Minimum length requirement
         * @param value - Initial value
         * @returns FormControl with minLength validation
         */
        minLength(length?: number, value?: string): FormControl<string>;
        /**
         * Creates a form control for URL input with validation
         * @param value - Initial value
         * @param required - Whether the field is required
         * @returns FormControl with URL validation
         */
        url(value?: string, required?: boolean): FormControl<string>;
        /**
         * Creates a form control with custom pattern validation
         * @param pattern - Regular expression pattern to validate against
         * @param required - Whether the field is required
         * @param value - Initial value
         * @returns FormControl with custom pattern validation
         */
        pattern(pattern: RegExp, required?: boolean, value?: any): FormControl<any>;
    }
}
/**
 * Instance of ConfigForms for use throughout the application
 */
declare const configForms: Forms.ConfigForms;
/**
 * Collection of regular expression patterns for form validation
 */
declare const configPatterns: {
    /** Pattern for date validation */
    date: RegExp;
    /** Pattern for email validation */
    email: RegExp;
    /** Pattern for integer validation */
    integer: RegExp;
    /** Pattern for name validation */
    name: RegExp;
    /** Pattern for number validation */
    number: RegExp;
    /** Pattern for phone number validation */
    phone: RegExp;
    /** Pattern for postal code validation */
    postal: RegExp;
    /** Pattern for URL validation */
    url: RegExp;
    /** Pattern for username validation */
    username: RegExp;
    /** Pattern for website URL validation */
    website: RegExp;
};

/**
 * Represents a single progress loader instance with tracking capabilities
 */
declare class ProgressLoader {
    /** The current progress value (0-100) */
    progress?: number;
    /** Whether the loader is currently active */
    isLoading?: boolean;
    /** Timestamp when the loader was created */
    timeAdded?: number;
    /** Text to display alongside the loader */
    loaderText: string;
    /** Unique identifier for this loader instance */
    readonly id: string;
    /**
     * Creates a new ProgressLoader instance
     * @param obj - Optional object to initialize the loader with
     */
    constructor(obj?: ProgressLoader);
}
/**
 * Manages multiple progress loaders and provides computed properties for tracking their states
 */
declare class ProgressLoaders {
    /** Signal containing all active loaders indexed by their IDs */
    readonly loaders: _angular_core.WritableSignal<{
        [id: string]: ProgressLoader;
    }>;
    /** Computed list of all active loaders */
    readonly loadersList: _angular_core.Signal<ProgressLoader[]>;
    /**
     * Computed property indicating if any loader is currently active
     * @returns true if any loader is loading, false otherwise
     */
    readonly isLoading: _angular_core.Signal<boolean>;
    /**
     * Computed property returning the most recently added active loader
     * @returns The latest active loader or undefined if none are active
     */
    readonly latestLoaderLoading: _angular_core.Signal<ProgressLoader>;
    /**
     * Computed property returning the text of the latest active loader
     * @returns The loader text or undefined if no loaders are active
     */
    readonly currentLoaderText: _angular_core.Signal<string>;
    /**
     * Adds a new loader to the collection
     * @param loader - Optional loader instance to add. If not provided, creates a new one
     * @returns The added loader instance
     */
    addLoader(loader?: ProgressLoader): ProgressLoader;
    /**
     * Updates properties of an existing loader
     * @param loaderID - The ID of the loader to update
     * @param value - Partial object containing the properties to update
     */
    updateLoader(loaderID: string, value: Omit<Partial<ProgressLoader>, 'id'>): void;
    /**
     * Removes all loaders from the collection
     */
    resetLoaders(): void;
    /**
     * Stops all active loaders
     * @returns The result of resetLoaders()
     */
    stopAll(): void;
}

/**
 * Generic class for managing selection state of items
 * @template T - Type of items being selected
 */
declare class SelectionData<T> {
    /**
     * Gets the first selected item
     * @returns The first selected item or undefined if no items are selected
     */
    get selectedItem(): T;
    /**
     * Array of currently selected items
     */
    selectedItems: T[];
    /**
     * Map tracking selection state by item ID
     */
    selectedMap: {
        [id: string]: boolean;
    };
    /**
     * Source data array containing all selectable items
     */
    sourceData: T[];
    /**
     * Gets the count of currently selected items
     * @returns Number of selected items
     */
    get count(): number;
    /**
     * Creates a new SelectionData instance
     * @param sourceArr - Array of items that can be selected
     */
    constructor(sourceArr: T[]);
    /**
     * Handles item selection state change
     * @param id - ID of the item whose selection state changed
     * @param e - Event containing the new checked state
     */
    itemChanged(id: string, e: {
        checked: boolean;
    }): void;
    /**
     * Adds an item to the selection
     * @param id - ID of the item to add
     */
    addSelectedItem(id: string): void;
    /**
     * Removes an item from the selection
     * @param id - ID of the item to remove
     */
    removeSelectedItem(id: string): void;
    /**
     * Resets the selection state, clearing all selected items
     */
    reset(): void;
}

/**
 * A component that provides functionality to add items to a form array or regular array
 * @example
 * ```html
 * <add-item
 *   [addText]="'Add New Item'"
 *   [formArray]="myFormArray"
 *   (clickedAdd)="onAddItem()">
 * </add-item>
 * ```
 */
declare class AddItemComponent {
    /**
     * The text to display on the add button
     * @default 'Add item'
     */
    addText: string;
    /**
     * The FormArray to which new items will be added
     */
    formArray: FormArray;
    /**
     * The regular array to which new items will be added
     */
    array: any[];
    /**
     * Event emitted when the add button is clicked
     */
    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>;
}

/**
 * Service that provides autocomplete filtering functionality
 * @example
 * ```ts
 * constructor(private autoS: AutocompleteService) {}
 *
 * filterOptions(query: string) {
 *   return this.autoS.filterOptions(query, this.options);
 * }
 * ```
 */
declare class AutocompleteService {
    constructor();
    /**
     * Filters options based on a query string
     * @param query - The search query
     * @param options - The list of options to filter
     * @returns Filtered list of options that match the query
     * @example
     * ```ts
     * const filtered = service.filterOptions('search', [
     *   { label: 'Search Result', value: 1 },
     *   { label: 'Other Item', value: 2 }
     * ]);
     * // Returns [{ label: 'Search Result', value: 1 }]
     * ```
     */
    filterOptions(query: string, options: IOption[]): IOption[];
    /**
     * Normalizes a string value for comparison by converting to lowercase and removing whitespace
     * @param value - The string to normalize
     * @returns Normalized string
     * @example
     * ```ts
     * const normalized = service.normalizeValue('Hello World');
     * // Returns 'helloworld'
     * ```
     */
    normalizeValue(value: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AutocompleteService>;
}

/**
 * A component that provides autocomplete functionality with Material Design
 * @example
 * ```html
 * <autocomplete
 *   [formControl]="myControl"
 *   [options]="myOptions"
 *   [filterFunc]="myFilterFunction"
 *   [validate]="true">
 * </autocomplete>
 * ```
 * @template TFormGroup - The type of the form group
 * @template TControl - The type of the form control
 * @template TOption - The type of the options
 */
declare class AutocompleteComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any, TControl = any, TOption = any> extends InputBasicComponent<TFormGroup, TControl, TOption> {
    autoS: AutocompleteService;
    dr: DestroyRef;
    /**
     * Computed property that filters options based on the current input value
     */
    readonly filteredOptions: _angular_core.Signal<IOption[]>;
    /**
     * Whether to validate the input value against available options
     * @default true
     */
    validate: boolean;
    /**
     * Custom function to filter options based on user input
     * @param query - The current input value
     * @param options - The available options
     * @returns Observable of filtered options
     */
    filterFunc: (query: string, options?: IOption[]) => Observable<any[]>;
    /**
     * Reference to the input element
     */
    readonly userInputElRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
    /**
     * Creates an instance of AutocompleteComponent
     * @param iS - The input service
     * @param autoS - The autocomplete service
     * @param dr - The destroy ref for cleanup
     */
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Handles the selection of an option from the autocomplete dropdown
     * @param e - The autocomplete selection event
     */
    selected(e: MatAutocompleteSelectedEvent): void;
    /**
     * Formats the display value of the selected option
     * @param val - The value to display
     * @returns The formatted display value
     */
    displayWith: (val: string) => string;
    /**
     * Validates that the selected value exists in the options list
     * @param control - The form control to validate
     * @returns Validation error if the value is not found in options, null otherwise
     */
    includesOption: (control: AbstractControl) => {
        notFound: boolean;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteComponent<any, any, any>, "app-autocomplete,autocomplete", never, { "validate": { "alias": "validate"; "required": false; }; "filterFunc": { "alias": "filterFunc"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Large button component that extends the base button component
 * @remarks
 * This component provides a larger variant of the standard button with additional features
 * like subtext and subvalue display.
 *
 * @example
 * ```html
 * <app-btn-lg
 *   [route]="'/dashboard'"
 *   [value]="'Dashboard'"
 *   [subText]="'View'"
 *   [subValue]="'Stats'"
 * ></app-btn-lg>
 * ```
 */
declare class BtnLgComponent extends BtnComponent {
    /** How to handle query parameters when navigating */
    queryParamsHandling: QueryParamsHandling;
    /** Route to navigate to when the button is clicked */
    route: string;
    /** Main value/text to display on the button */
    value: string | number;
    /** Subtext to display below the main value */
    subText: string;
    /** Subvalue to display below the subtext */
    subValue: string | number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnLgComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BtnLgComponent, "app-btn-lg", never, { "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; }; "route": { "alias": "route"; "required": false; }; "value": { "alias": "value"; "required": false; }; "subText": { "alias": "subText"; "required": false; }; "subValue": { "alias": "subValue"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * A component that extends BtnComponent to create a button that behaves as a link.
 * This component supports various types of links including router links, email links, and telephone links.
 *
 * @example
 * ```html
 * <app-btn-link route="/home" [params]="{id: 1}">Home</app-btn-link>
 * <app-btn-link emailTo="contact@example.com">Email Us</app-btn-link>
 * <app-btn-link tel="+1234567890">Call Us</app-btn-link>
 * ```
 */
declare class BtnLinkComponent extends BtnComponent {
    /**
     * Specifies how query parameters should be handled when navigating.
     * This is used in conjunction with Angular's RouterLink.
     */
    readonly mqueryParamsHandling: _angular_core.InputSignal<QueryParamsHandling>;
    /**
     * The route path to navigate to when the button is clicked.
     * This is used for internal navigation within the application.
     */
    readonly route: _angular_core.InputSignal<string>;
    /**
     * Additional parameters to be included in the route navigation.
     * These parameters will be converted to query parameters in the URL.
     */
    readonly params: _angular_core.InputSignal<{
        [x: string]: string | number | boolean;
    }>;
    /**
     * Email address to create a mailto link.
     * When specified, clicking the button will open the default email client.
     */
    readonly emailTo: _angular_core.InputSignal<string>;
    /**
     * Telephone number to create a tel link.
     * When specified, clicking the button will initiate a phone call on supported devices.
     */
    readonly tel: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnLinkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BtnLinkComponent, "app-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; }; "tel": { "alias": "tel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Component for handling chip list with autocomplete functionality
 * @remarks
 * This component extends InputBasicComponent to provide a chip list input with autocomplete support.
 * It allows users to add and remove chips from a list, with suggestions provided through autocomplete.
 *
 * @example
 * ```html
 * <chip-list-autocomplete
 *   [filterFunc]="filterFunction"
 *   [addedDataFormatter]="formatFunction">
 * </chip-list-autocomplete>
 * ```
 */
declare class ChipListAutocompleteComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any, TOption = any> extends InputBasicComponent<TFormGroup, string[], TOption> {
    autoS: AutocompleteService;
    /** Key codes that trigger chip addition */
    separatorKeysCodes: number[];
    /** Form control for autocomplete input */
    autoCompleteCtrl: FormControl<string>;
    /** Function to filter options based on input */
    filterFunc: (...args: any[]) => Observable<any[]>;
    /** Reference to the input element */
    fruitInput: ElementRef<HTMLInputElement>;
    readonly autoCompleteValue: _angular_core.Signal<string>;
    /** Currently filtered options */
    readonly filteredOptions: _angular_core.Signal<IOption[]>;
    /** Function to format added data */
    addedDataFormatter: (param: string) => Observable<string>;
    /** Message to display */
    message: string;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Adds a new chip to the list
     * @param event - The chip input event
     */
    add(event: MatChipInputEvent): void;
    /**
     * Removes a chip from the list
     * @param index - The index of the chip to remove
     */
    remove(index: number): void;
    /**
     * Handles selection from autocomplete
     * @param event - The autocomplete selection event
     */
    selected(event: MatAutocompleteSelectedEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipListAutocompleteComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipListAutocompleteComponent<any, any>, "chip-list-autocomplete", never, { "filterFunc": { "alias": "filterFunc"; "required": false; }; "addedDataFormatter": { "alias": "addedDataFormatter"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for displaying a confirmation dialog
 * @remarks
 * This component provides a simple dialog for confirming actions with yes/no options.
 * It displays a question mark icon and the provided text, allowing users to confirm or cancel.
 *
 * @example
 * ```html
 * <app-confirm-dialog [text]="'Are you sure you want to delete this item?'">
 * </app-confirm-dialog>
 * ```
 */
declare class ConfirmDialogComponent implements OnInit {
    text: any;
    dialogRef: MatDialogRef<ConfirmDialogComponent, any>;
    ngOnInit(): void;
    /**
     * Handles the yes action, closing the dialog with true
     */
    yes(): void;
    /**
     * Handles the no action, closing the dialog with false
     */
    no(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDialogComponent, "app-confirm-dialog", never, {}, {}, never, never, true, never>;
}

/**
 * Component for displaying a count value with optional formatting
 * @remarks
 * This component displays a numeric or string count value with optional CSS classes for styling.
 * It uses the ValueOrXPipe to format the count value.
 *
 * @example
 * ```html
 * <count [count]="5" class="text-primary"></count>
 * ```
 */
declare class CountComponent {
    /**
     * The count value to display
     * @remarks
     * Can be either a number or string value
     */
    count: number | string;
    /**
     * CSS classes to apply to the count element
     * @remarks
     * Used for styling the count display
     */
    class: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CountComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CountComponent, "count", never, { "count": { "alias": "count"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for handling file uploads
 * @remarks
 * This component provides file upload functionality with support for single and multiple files,
 * file type restrictions, and image preview. It can be used with or without a document modal.
 *
 * @example
 * ```html
 * <app-file-upload
 *   [label]="'Upload File'"
 *   [accept]="'image/*'"
 *   [multiple]="false"
 *   (fileChange)="onFileSelected($event)">
 * </app-file-upload>
 * ```
 */
declare class FileUploadComponent {
    uS: UtilityService;
    /**
     * Help text to display
     */
    help: string;
    /**
     * Label for the upload button
     */
    label: string;
    /**
     * CSS classes to apply
     */
    class: string;
    /**
     * Icon to display on the upload button
     */
    icon: SVGIconType;
    /**
     * Whether the upload is disabled
     */
    disabled: boolean;
    /**
     * Whether multiple files can be uploaded
     */
    multiple: boolean;
    /**
     * Whether to use mini style
     */
    mini: boolean;
    /**
     * Whether to use document modal
     */
    useDocumentModal: boolean;
    /**
     * Whether to list uploaded files
     */
    listFiles: boolean;
    /**
     * Accepted file types
     * @remarks
     * Can be a specific file type or a predefined type like 'image'
     */
    accept: string;
    /**
     * Setter for accept property
     * @remarks
     * Handles special cases like 'image' type
     */
    set _accept(v: string);
    /**
     * Currently selected file
     */
    file: File;
    /**
     * Event emitted when file changes
     */
    fileChange: EventEmitter<File>;
    /**
     * Currently selected files
     */
    files: File[];
    /**
     * Event emitted when files change
     */
    filesChange: EventEmitter<File[]>;
    /**
     * Base64 string of uploaded image
     */
    imageString: string;
    /**
     * Whether single file upload is enabled
     */
    get isSingle(): boolean;
    /**
     * Accepts and processes uploaded files
     * @param files - Files to process
     * @remarks
     * Handles image preview for image files
     */
    private acceptFiles;
    /**
     * Emits file change events
     */
    private emitFiles;
    /**
     * Handles file upload event
     * @param event - File upload event
     */
    onUpload(event: any): void;
    /**
     * Removes a file from the selection
     * @param index - Index of file to remove
     */
    removeFile(index: number): void;
    /**
     * Opens 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; }; "class": { "alias": "class"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "mini": { "alias": "mini"; "required": false; }; "useDocumentModal": { "alias": "useDocumentModal"; "required": false; }; "listFiles": { "alias": "listFiles"; "required": false; }; "_accept": { "alias": "accept"; "required": false; }; "file": { "alias": "file"; "required": false; }; "files": { "alias": "files"; "required": false; }; }, { "fileChange": "fileChange"; "filesChange": "filesChange"; }, never, never, true, never>;
}

/**
 * Component for handling form inputs with template-driven and reactive form support
 * @remarks
 * This component extends the basic input component to provide additional functionality
 * for both template-driven and reactive forms.
 *
 * @example
 * ```html
 * <app-input-td-rf
 *   [model]="formData"
 *   [validators]="[Validators.required]"
 *   [asyncValidators]="[asyncValidator]"
 *   (modelChange)="onModelChange($event)"
 * ></app-input-td-rf>
 * ```
 */
declare class InputTD_RFComponent<TOption = any> extends InputBasicComponent<any, TOption> {
    /** Array of synchronous validators */
    validators?: ValidatorFn[];
    /** Sets the synchronous validators for the control */
    set _validators(v: ValidatorFn[]);
    /** Array of asynchronous validators */
    asyncValidators?: AsyncValidatorFn[];
    /** Sets the asynchronous validators for the control */
    set _asyncValidators(v: AsyncValidatorFn[]);
    /** Current model value */
    private model?;
    /** Sets the model value and updates the control */
    set _model(v: any);
    /** Event emitter for model changes */
    modelChange: EventEmitter<any>;
    /** Sets the disabled state of the control */
    set _disabled(v: boolean);
    constructor();
    /**
     * Initializes the component and sets up value change subscriptions
     */
    ngOnInit(): void;
    /**
     * Called after the view is initialized
     */
    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; }; "_disabled": { "alias": "disabled"; "required": false; }; }, { "modelChange": "modelChange"; }, never, never, true, never>;
}

/**
 * Table-driven form generator component
 * @remarks
 * This component extends the base FormGeneratorComponent to provide table-driven form generation capabilities.
 * It adds support for headers, dividers, and value change events specific to table-driven forms.
 *
 * @example
 * ```html
 * <form-generator-td
 *   [header]="'Form Title'"
 *   [showDivider]="true"
 *   [subTitle]="'Subtitle'"
 *   (valuesChange)="handleValuesChange($event)">
 * </form-generator-td>
 * ```
 */
declare class FormGeneratorTdComponent extends FormGeneratorComponent {
    /**
     * Header text to display above the form
     */
    header: string;
    /**
     * Whether to show a divider below the header
     */
    showDivider: boolean;
    /**
     * Subtitle text to display below the header
     */
    subTitle: string;
    /**
     * Event emitted when form values change
     * @event
     */
    _valuesChange: EventEmitter<{
        form: IFormSchema[];
    }>;
    /**
     * Overrides the base onChange method to emit values change event
     * @param field - The form field that changed
     * @param inp - The input component instance
     */
    onChange(field: IFormSchema, inp: InputTD_RFComponent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormGeneratorTdComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormGeneratorTdComponent, "form-generator-td", never, { "header": { "alias": "header"; "required": false; }; "showDivider": { "alias": "showDivider"; "required": false; }; "subTitle": { "alias": "subTitle"; "required": false; }; }, { "_valuesChange": "valuesChange"; }, never, ["[response]"], true, never>;
}

/**
 * Interface for row options in a table
 * @remarks
 * Defines the configuration for actions and display options available for each row
 */
interface IRowOption<T = any> {
    /**
     * CSS class to apply to the option
     */
    optionClass?: string;
    /**
     * Text to display for the option
     */
    t: string;
    /**
     * CSS class for the option's icon
     */
    iconClass?: string;
    /**
     * SVG icon to display
     */
    svgIcon?: EIcon;
    /**
     * Whether to ignore this option
     */
    ignore?: boolean;
    /**
     * Action to perform when the option is clicked
     */
    action?: (row: T) => void;
    /**
     * Function to format the option's label
     */
    labelFormatter?: (row: T) => string;
}
/**
 * Type for table cell content
 * @remarks
 * Defines the possible types of content that can be displayed in a table cell
 */
type CellType = InputType | 'table' | 'btns' | 'editable' | 'image' | 'trend' | 'assign-from-list';
/**
 * Interface for table column configuration
 * @remarks
 * Defines how a column should be displayed and behave in the table
 */
interface ITableCol<T = any> {
    /**
     * CSS class to apply to the cell
     */
    cellClass?: string;
    /**
     * Whether the cell is disabled
     */
    disabled?: boolean;
    /**
     * Field name in the row data
     */
    f: keyof T;
    /**
     * Function to format the cell value
     */
    formatter?: (val: any) => string | Promise<string>;
    /**
     * Function to format the cell value with parameters
     */
    formatterP?: (...val: any) => string;
    /**
     * CSS class to apply to the cell's content
     */
    itemClass?: string;
    /**
     * Function to determine the cell's content class
     */
    itemClassFunc?: (val: T) => string;
    /**
     * Additional parameters for the formatter
     */
    p?: string[];
    /**
     * Column header text
     */
    t: string;
    /**
     * Whether to ignore this column
     */
    ignore?: boolean;
    /**
     * Type of content to display in the cell
     */
    type?: CellType;
    /**
     * Button configuration for the cell
     */
    btn?: ITableBtn;
}
/**
 * Interface for table button configuration
 * @remarks
 * Extends IBtn to add table-specific button functionality
 */
interface ITableBtn<TRow = any> extends IBtn {
    /**
     * Action to perform when the button is clicked
     */
    action?: (param: {
        row: TRow;
        btn: BtnComponent;
        index: number;
    }) => void;
}
/**
 * Class for table column configuration
 * @remarks
 * Implements ITableCol with additional functionality for table operations
 */
declare class TableCol<TRow = any, TOption = {
    value: string;
    label: string;
}> implements ITableCol {
    /**
     * Action to perform on the row
     */
    action?: (row: any, cellField: keyof TRow, setLoading?: (value: boolean) => void) => any;
    /**
     * Button configuration
     */
    btn?: ITableBtn<TRow>;
    /**
     * Array of buttons
     */
    buttons?: ITableBtn<TRow>[];
    /**
     * CSS class for the cell
     */
    cellClass?: string;
    /**
     * Whether the cell is checked
     */
    checked?: boolean;
    /**
     * Whether the column is sticky
     */
    isSticky?: boolean;
    /**
     * Whether the column is sticky at the end
     */
    isStickyEnd?: boolean;
    /**
     * Whether to ignore this column
     */
    ignore?: boolean;
    /**
     * Whether to hide this column
     */
    hide?: boolean;
    /**
     * Whether the column is disabled
     */
    disabled?: boolean;
    /**
     * Field name in the row data
     */
    f: keyof TRow;
    /**
     * Function to format the cell value
     */
    formatter?: (val: any) => string | Promise<string>;
    /**
     * Function to format the row data
     */
    formatterRow?: FormatterFuncType<TRow>;
    /**
     * Help text for the column
     */
    help?: string;
    /**
     * CSS class for the cell's content
     */
    itemClass?: string;
    /**
     * Function to determine the cell's content class
     */
    itemClassFunc?: (val: TRow) => string;
    /**
     * Function to format query parameters
     */
    mqueryParams?: QueryParamsFormatterFuncType<TRow>;
    /**
     * Additional parameters
     */
    p?: string[];
    /**
     * Function to format route parameters
     */
    routeFormatter?: FormatterFuncType<TRow>;
    /**
     * Custom template for the cell
     */
    customTemplate?: any;
    /**
     * Nested table columns
     */
    subTable?: TableCol[];
    /**
     * Column header text
     */
    t: string;
    /**
     * Type of content to display
     */
    type?: CellType;
    /**
     * Function to get list options
     */
    listingFunction?: TListFunction<TRow, TOption>;
    /**
     * Action to perform when an item is selected
     */
    onSelected?: (item: keyof TOption, row: TRow, index: number) => any;
    /**
     * Whether the item is selected
     */
    selected?: boolean;
    /**
     * Current value
     */
    value?: any;
    constructor(t: string, f?: keyof TRow, formatter?: (val: any) => string | Promise<string>, formatterRow?: FormatterFuncType, type?: CellType, checked?: boolean, routeFormatter?: FormatterFuncType<TRow>, mqueryParams?: QueryParamsFormatterFuncType<TRow>, action?: (row: any, cellField: keyof TRow) => any);
}
/**
 * Type for row formatting function
 */
type FormatterFuncType<TRow = any> = (row: TRow, cellField?: string) => string;
/**
 * Type for query parameters formatting function
 */
type QueryParamsFormatterFuncType<TRow = any> = (row: TRow) => {
    [x: string]: string | boolean | number;
};
/**
 * Type for sort direction
 */
type SortType = 'asc' | 'desc';
/**
 * Type for list options function
 */
type TListFunction<T, TOption = {
    value: string;
    label: string;
}> = (row: T) => Observable<TOption[]>;
/**
 * Type for row options mapping function
 */
type IRowOptionMap<TRow = any> = (row: TRow) => IRowOption<TRow>[];

/**
 * Component for displaying data in either grid or list view
 * @remarks
 * This component provides functionality to switch between grid and list views of data.
 * It supports selection, search, and various display options.
 *
 * @example
 * ```html
 * <grid-or-list
 *   [data]="items"
 *   [displayedColumns]="columns"
 *   [loading]="isLoading"
 *   (onEdit)="handleEdit($event)">
 * </grid-or-list>
 * ```
 */
declare class GridOrListComponent<TItem> {
    uS: UtilityService;
    route: ActivatedRoute;
    /**
     * Enum for view types
     */
    eViewType: typeof EViewType;
    /**
     * Available view type options
     */
    viewTypes: IListValue<EViewType>[];
    /**
     * Current view type
     */
    viewType: any;
    /**
     * Columns to display in the table
     */
    displayedColumns: TableCol<TItem>[];
    /**
     * Fields to display in the table
     */
    displayedColumnsFields: (keyof TItem)[];
    /**
     * Main field for display
     */
    mainField: TableCol<TItem>;
    /**
     * Secondary fields for display
     */
    subFields: TableCol<TItem>[];
    /**
     * Navigation breadcrumbs
     */
    breadcrumbs: TableCol[];
    /**
     * Loading state
     */
    loading: boolean;
    /**
     * Model ID
     */
    mID: string;
    /**
     * Parent ID
     */
    parentID: string;
    /**
     * Event emitted when an item is edited
     */
    onEdit: EventEmitter<TItem>;
    /**
     * Options for row actions
     */
    rowOptions: IRowOption<TItem>[];
    /**
     * Current page name
     */
    pageName: string;
    /**
     * ID values for navigation
     */
    idValues: {
        [x: string]: string;
    };
    /**
     * Setter for displayed columns
     */
    set _displayedColumns(value: TableCol<TItem>[]);
    /**
     * Internal data storage
     */
    protected data: TItem[];
    /**
     * Setter for data
     */
    set _data(v: TItem[]);
    /**
     * Function to handle item deletion
     */
    deleteFunc: (items: TItem[]) => Observable<any>;
    /**
     * Function to search for items
     */
    protected searchFunction: (id?: string) => Observable<TItem[]>;
    /**
     * Setter for search function
     */
    set _searchFunction(v$: (id?: string) => Observable<TItem[]>);
    /**
     * Selection data
     */
    selection: SelectionData<TItem>;
    /**
     * Initializes component
     */
    ngOnInit(): void;
    /**
     * Fetches data using the provided search function
     * @param v$ - Search function to use
     */
    protected fetchData(v$: (id?: string) => Observable<TItem[]>): void;
    /**
     * Switches the view type
     * @param vt - View type to switch to
     */
    switchView(vt: IListValue<EViewType, any>): void;
    /**
     * Handles table selection changes
     * @param r - Selection change event
     */
    tableSelection(r: SelectionChange<TItem>): void;
    /**
     * Deletes selected items
     * @param items - Items to delete
     */
    deleteItems(items: TItem[]): Promise<void>;
    /**
     * Refreshes the data
     */
    refresh(): void;
    /**
     * Forms breadcrumbs for navigation
     */
    formBreadCrumbs(): void;
    /**
     * Forms query parameters for navigation
     * @param row - Current row data
     * @returns Query parameters object
     */
    formQueryParams: (row: TItem) => {
        [x: string]: any;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridOrListComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridOrListComponent<any>, "grid-or-list", never, { "viewType": { "alias": "viewType"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "mID": { "alias": "mID"; "required": false; }; "parentID": { "alias": "parentID"; "required": false; }; "_displayedColumns": { "alias": "displayedColumns"; "required": false; }; "_data": { "alias": "data"; "required": false; }; "deleteFunc": { "alias": "deleteFunc"; "required": false; }; "_searchFunction": { "alias": "searchFunction"; "required": false; }; }, { "onEdit": "onEdit"; }, never, never, true, never>;
}
/**
 * Enum for view types
 */
declare enum EViewType {
    list = "list",
    grid = "grid"
}

/**
 * Service for managing user idle state
 * @remarks
 * This service monitors user activity and manages session timeouts.
 * It provides functionality to start idle monitoring, handle timeouts,
 * and execute custom functions when the user becomes idle.
 */
declare class IdlerService {
    private idle;
    dialog: MatDialog;
    /**
     * Current idle state
     */
    private idleState;
    /**
     * Whether the session has timed out
     */
    private timedOut;
    /**
     * Functions to execute when user becomes idle
     */
    private onIdleFunctions;
    /**
     * Time remaining before timeout
     */
    private _timeLeft;
    /**
     * Reference to the idle warning dialog
     */
    idlerModal: MatDialogRef<IdlerComponent>;
    /**
     * Gets the time remaining before timeout
     */
    get timeLeft(): number;
    /**
     * Default idle time in seconds
     */
    private idleTime;
    /**
     * Default timeout time in seconds
     */
    private timeOutTime;
    /**
     * Starts the idle monitoring system
     * @param idleTimeSec - Custom idle time in seconds
     */
    startIdler(idleTimeSec?: number): void;
    /**
     * Resets the idle monitoring
     */
    private reset;
    /**
     * Clears all idle functions
     */
    clear(): void;
    /**
     * Adds a function to execute when user becomes idle
     * @param func - Function to execute
     */
    addOnIdleFunction(func: any): void;
    /**
     * Opens the idle warning modal
     */
    openTimeWarningModal(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdlerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IdlerService>;
}

/**
 * Component for displaying idle timeout warning
 * @remarks
 * This component provides a dialog interface for warning users about session timeouts.
 * It allows users to acknowledge the warning and prevent session expiration.
 */
declare class IdlerComponent implements OnInit {
    dialogRef: MatDialogRef<IdlerComponent, any>;
    idlerService: IdlerService;
    uS: UtilityService;
    ngOnInit(): void;
    /**
     * Closes the idle warning dialog
     */
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdlerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdlerComponent, "app-idler", never, {}, {}, never, never, true, never>;
}

/**
 * Component for displaying text with various formatting options
 * @remarks
 * This component provides a flexible way to display text with options for:
 * - Custom formatting
 * - Routing
 * - Email/phone number detection
 * - Styling (bold, colored, etc.)
 * - Tooltips
 */
declare class TextCase2Component implements OnInit, ITextCase2 {
    asyncPipe: AsyncPipe;
    /**
     * Setter for object properties
     * @param v - Object containing properties to set
     */
    set obj(v: ITextCase2);
    /**
     * Action to perform when clicked
     */
    action: any;
    /**
     * Name of the field
     */
    name: string;
    /**
     * Whether to use colored label
     * @default true
     */
    coloredLbl: boolean;
    /**
     * Whether to use colored value
     */
    coloredVal: boolean;
    /**
     * Form reference
     */
    form: any;
    /**
     * Custom template for value display
     */
    customValueTemplate: TemplateRef<any>;
    /**
     * Function to format the value
     */
    formatter: (item: any) => string | Promise<string> | Observable<string>;
    /**
     * Tooltip text
     */
    hint: string;
    /**
     * Label text
     */
    label: string;
    /**
     * Whether to use light styling
     */
    light: boolean;
    /**
     * Whether to use mini styling
     */
    mini: boolean;
    /**
     * Route for navigation
     */
    route: string;
    /**
     * Function to generate route
     */
    routeFunc: (item: any) => Promise<string> | Observable<string>;
    /**
     * Whether the text is editable
     */
    editable: boolean;
    /**
     * Whether to use stacked layout
     * @default true
     */
    stacked: boolean;
    /**
     * Input type
     */
    type: InputType;
    /**
     * Current value
     */
    value?: any;
    /**
     * Whether to wrap label
     * @default true
     */
    wrapLabel: boolean;
    /**
     * Whether the value is an email
     */
    isEmail: boolean;
    /**
     * Whether the value is a phone number
     */
    isPhone: boolean;
    /**
     * Whether to use bold label
     */
    boldLabel: _angular_core.InputSignal<boolean>;
    /**
     * Whether to use bold value
     */
    boldValue: _angular_core.InputSignal<boolean>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextCase2Component, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextCase2Component, "text-case", never, { "obj": { "alias": "obj"; "required": false; }; "action": { "alias": "action"; "required": false; }; "coloredLbl": { "alias": "coloredLbl"; "required": false; }; "coloredVal": { "alias": "coloredVal"; "required": false; }; "form": { "alias": "form"; "required": false; }; "customValueTemplate": { "alias": "customValueTemplate"; "required": false; }; "formatter": { "alias": "formatter"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "label": { "alias": "label"; "required": false; }; "light": { "alias": "light"; "required": false; }; "mini": { "alias": "mini"; "required": false; }; "route": { "alias": "route"; "required": false; }; "routeFunc": { "alias": "routeFunc"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "wrapLabel": { "alias": "wrapLabel"; "required": false; }; "isEmail": { "alias": "isEmail"; "required": false; }; "isPhone": { "alias": "isPhone"; "required": false; }; "boldLabel": { "alias": "boldLabel"; "required": false; "isSignal": true; }; "boldValue": { "alias": "boldValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Generic class for text case configuration
 * @remarks
 * Provides a type-safe way to configure text display for objects
 */
declare class TextCase2ForObject<T = any> implements ITextCase2 {
    /**
     * Name of the field
     */
    name: keyof T;
    /**
     * Action to perform when clicked
     */
    action: any;
    /**
     * Whether to use colored label
     */
    coloredLbl: boolean;
    /**
     * Whether to use colored value
     */
    coloredVal: boolean;
    /**
     * Form reference
     */
    form: any;
    /**
     * Function to format the value
     */
    formatter: (item: any) => string | Promise<string> | Observable<string>;
    /**
     * Tooltip text
     */
    hint: string;
    /**
     * Label text
     */
    label: string;
    /**
     * Whether to use light styling
     */
    light: boolean;
    /**
     * Whether to use mini styling
     */
    mini: boolean;
    /**
     * Route for navigation
     */
    route: string;
    /**
     * Function to generate route
     */
    routeFunc: (item: any) => Promise<string> | Observable<string>;
    /**
     * Whether the text is editable
     */
    editable: boolean;
    /**
     * Whether to use stacked layout
     * @default true
     */
    stacked: boolean;
    /**
     * Input type
     */
    type: InputType;
    /**
     * Current value
     */
    value: any;
    /**
     * Whether to wrap label
     * @default true
     */
    wrapLabel: boolean;
    /**
     * Whether the value is an email
     */
    isEmail: boolean;
    /**
     * Whether the value is a phone number
     */
    isPhone: boolean;
    constructor(name: keyof T, label: string, extra?: {
        formatter: (item: any) => string | Promise<string> | Observable<string>;
    });
}
/**
 * Interface for text case configuration
 * @remarks
 * Defines the configuration options for text display
 */
interface ITextCase2<T = any> {
    /**
     * Action to perform when clicked
     */
    action?: any;
    /**
     * Whether to use colored label
     */
    coloredLbl?: boolean;
    /**
     * Whether to use colored value
     */
    coloredVal?: boolean;
    /**
     * Whether the text is editable
     */
    editable?: boolean;
    /**
     * Function to format the value
     */
    formatter?: (item: any) => string | Promise<string> | Observable<string>;
    /**
     * Tooltip text
     */
    hint?: string;
    /**
     * Whether the value is an email
     */
    isEmail?: boolean;
    /**
     * Whether the value is a phone number
     */
    isPhone?: boolean;
    /**
     * Label text
     */
    label?: string;
    /**
     * Whether to use light styling
     */
    light?: boolean;
    /**
     * Whether to use mini styling
     */
    mini?: boolean;
    /**
     * Name of the field
     */
    name?: keyof T;
    /**
     * Route for navigation
     */
    route?: string;
    /**
     * Function to generate route
     */
    routeFunc?: (item: any) => Promise<string> | Observable<string>;
    /**
     * Whether to use stacked layout
     */
    stacked?: boolean;
    /**
     * Input type
     */
    type?: InputType;
    /**
     * Current value
     */
    value?: any;
    /**
     * Whether to wrap label
     */
    wrapLabel?: boolean;
}

/**
 * Core loader component that provides basic loading functionality
 * @remarks
 * This component serves as the base implementation for loading indicators,
 * providing height, class, progress, and text display capabilities.
 *
 * @example
 * ```html
 * <lib-loader-core
 *   [height]="'100px'"
 *   [class]="'vh-60'"
 *   [progress]="50"
 *   [text]="'Loading...'">
 * </lib-loader-core>
 * ```
 */
declare class LoaderCoreComponent {
    /** Height of the loader component */
    readonly height: _angular_core.InputSignal<string>;
    /** CSS class to apply to the loader */
    readonly class: _angular_core.InputSignal<string>;
    /** Progress value (0-100) to display */
    readonly progress: _angular_core.InputSignal<number>;
    /** Text to display in the loader */
    readonly text: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderCoreComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderCoreComponent, "lib-loader-core", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Configuration interface for loader components
 * @remarks
 * This interface defines the configuration options for loader components,
 * allowing customization of the loader component type and default height class.
 *
 * @example
 * ```typescript
 * const loaderConfig: ILoaderConfig = {
 *   loaderComponent: CustomLoaderComponent,
 *   defaultClass: 'vh-60'
 * };
 * ```
 */
interface ILoaderConfig {
    /** Custom loader component to use */
    loaderComponent?: Type<LoaderCoreComponent>;
    /** Default height class for the loader */
    defaultClass: classes;
}
/**
 * Available height classes for loader components
 * @remarks
 * These classes define the vertical height of the loader component,
 * ranging from auto height to full viewport height.
 */
type classes = 'h-100' /** 100% height */ | 'h-auto' /** Auto height */ | 'vh-10' /** 10% viewport height */ | 'vh-20' /** 20% viewport height */ | 'vh-30' /** 30% viewport height */ | 'vh-40' /** 40% viewport height */ | 'vh-50' /** 50% viewport height */ | 'vh-60' /** 60% viewport height */ | 'vh-70' /** 70% viewport height */ | 'vh-80' /** 80% viewport height */ | 'vh-90' /** 90% viewport height */ | 'vh-95' /** 95% viewport height */ | 'vh-100'; /** 100% viewport height */

/**
 * Service for managing loader configuration and state
 * @remarks
 * This service provides a centralized way to manage loader configuration
 * and state across the application.
 *
 * @example
 * ```typescript
 * constructor(private loaderService: LoaderService) {
 *   // Update loader configuration
 *   this.loaderService.updateConfig({
 *     defaultClass: 'vh-80'
 *   });
 * }
 * ```
 */
declare class LoaderService {
    /** Signal containing the current loader configuration */
    protected readonly _config: _angular_core.WritableSignal<ILoaderConfig>;
    /** Computed configuration that returns a copy of the current config */
    readonly config: _angular_core.Signal<{
        loaderComponent?: _angular_core.Type<LoaderCoreComponent>;
        defaultClass: "h-100" | "h-auto" | "vh-10" | "vh-20" | "vh-30" | "vh-40" | "vh-50" | "vh-60" | "vh-70" | "vh-80" | "vh-90" | "vh-95" | "vh-100";
    }>;
    constructor();
    /**
     * Updates the loader configuration
     * @param config - Partial configuration to update
     */
    updateConfig(config: Partial<ILoaderConfig>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoaderService>;
}

/**
 * Main loader component that provides advanced loading functionality
 * @remarks
 * This component extends the basic loader functionality with support for multiple
 * loaders, progress tracking, and content state management.
 *
 * @example
 * ```html
 * <loader
 *   [height]="300"
 *   [hasContent]="true"
 *   [text]="'Loading data...'">
 *   <!-- Content to show when not loading -->
 * </loader>
 * ```
 */
declare class LoaderComponent {
    /** Injected loader service */
    protected service: LoaderService;
    /** CSS class for the loader */
    readonly class: _angular_core.InputSignal<"h-100" | "h-auto" | "vh-10" | "vh-20" | "vh-30" | "vh-40" | "vh-50" | "vh-60" | "vh-70" | "vh-80" | "vh-90" | "vh-95" | "vh-100">;
    /** Text to display in the loader */
    readonly text: _angular_core.ModelSignal<string>;
    /** Whether the loader has content to show when not loading */
    hasContent: boolean;
    /** Current progress value */
    readonly progress: _angular_core.WritableSignal<number>;
    /** Loading state */
    readonly loading: _angular_core.ModelSignal<boolean>;
    /** Computed loading state that considers both local and loader collection state */
    readonly cLoading: _angular_core.Signal<boolean>;
    /** Computed loader inputs for the core loader component */
    readonly loaderInputs: _angular_core.Signal<{
        height: string;
        class: string;
        progress: number;
        text: string;
    }>;
    /** Collection of progress loaders */
    readonly loaders: ProgressLoaders;
    /** Height of the loader */
    readonly height: _angular_core.WritableSignal<string>;
    /**
     * Sets the height of the loader with a minimum height constraint
     * @param v - The height value to set
     */
    set _height(v: number);
    constructor();
    /**
     * Starts the loader
     */
    startLoader(): void;
    /**
     * Stops the loader
     */
    stopLoader(): void;
    /**
     * Sets the loader state
     * @param v - The loading state to set
     */
    setLoader(v: boolean): 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; }; "hasContent": { "alias": "hasContent"; "required": false; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "_height": { "alias": "height"; "required": false; }; }, { "text": "textChange"; "loading": "loadingChange"; }, never, ["*", "[content]", "[noContent]"], true, never>;
}

/**
 * Directive for marking a template as the body content of a modal
 * @remarks
 * This directive is used to identify the template that should be used
 * as the body content of a modal component.
 *
 * @example
 * ```html
 * <ng-template modalBody>
 *   <!-- Modal body content -->
 * </ng-template>
 * ```
 */
declare class ModalBodyDirective {
    templateRef: TemplateRef<unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalBodyDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalBodyDirective, "[modalBody]", never, {}, {}, never, never, true, never>;
}

/**
 * Directive for marking a template as the footer content of a modal
 * @remarks
 * This directive is used to identify the template that should be used
 * as the footer content of a modal component.
 *
 * @example
 * ```html
 * <ng-template modalFooter>
 *   <!-- Modal footer content -->
 * </ng-template>
 * ```
 */
declare class ModalFooterDirective {
    templateRef: TemplateRef<unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFooterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalFooterDirective, "[modalFooter]", never, {}, {}, never, never, true, never>;
}

declare class ModalService {
    protected readonly _modalConfig: _angular_core.WritableSignal<MatDialogConfig<any>>;
    protected readonly _mobileModalConfig: _angular_core.WritableSignal<MatDialogConfig<any>>;
    protected readonly _sideModalConfig: _angular_core.WritableSignal<MatDialogConfig<any>>;
    readonly modalConfig: _angular_core.Signal<MatDialogConfig<any>>;
    readonly mobileModalConfig: _angular_core.Signal<MatDialogConfig<any>>;
    readonly sideModalConfig: _angular_core.Signal<MatDialogConfig<any>>;
    readonly onOpen$: Subject<ModalComponent>;
    constructor();
    setModalConfig(data: MatDialogConfig): void;
    setMobileModalConfig(data: MatDialogConfig): void;
    setSideModalConfig(data: MatDialogConfig): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ModalService>;
}

/**
 * Base modal component that provides common modal functionality
 * @remarks
 * This component serves as the base implementation for all modal types in the application.
 * It provides features like fullscreen mode, loading states, header/footer templates,
 * and configurable dimensions.
 *
 * @example
 * ```html
 * <modal-comp
 *   [isFullscreen]="false"
 *   [header]="'Modal Title'"
 *   [height]="'500px'"
 *   [width]="'600px'">
 *   <!-- Modal content -->
 * </modal-comp>
 * ```
 */
declare class ModalComponent {
    /** Whether the modal should be displayed in fullscreen mode */
    readonly isFullscreen: _angular_core.InputSignal<boolean>;
    /** Additional dialog configuration data */
    readonly data: _angular_core.InputSignal<MatDialogConfig<any>>;
    /** Whether to disable closing the modal by clicking outside */
    readonly disableClose: _angular_core.InputSignal<boolean>;
    /** Header text for the modal */
    readonly header: _angular_core.InputSignal<string>;
    /** Custom header template */
    readonly headerTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Height of the modal */
    readonly height: _angular_core.InputSignal<string>;
    /** Reference to the loader component */
    readonly loaderRef: _angular_core.Signal<LoaderComponent>;
    /** Whether the modal is in a loading state */
    readonly loading: _angular_core.InputSignal<boolean>;
    /** Event emitted when the modal is closed */
    readonly onClose: _angular_core.OutputEmitterRef<any>;
    /** Internal show footer flag */
    readonly _showFooter: _angular_core.InputSignal<boolean>;
    /** Computed show footer flag that considers fullscreen mode */
    readonly showFooter: _angular_core.Signal<boolean>;
    /** Internal show header flag */
    readonly _showHeader: _angular_core.InputSignal<boolean>;
    /** Computed show header flag that considers fullscreen mode */
    readonly showHeader: _angular_core.Signal<boolean>;
    /** Reference to the modal template */
    readonly tempRef: _angular_core.Signal<TemplateRef<any>>;
    /** Width of the modal */
    readonly width: _angular_core.InputSignal<string>;
    readonly panelClass: _angular_core.InputSignal<string>;
    /** Reference to the dialog */
    readonly dialogRef: _angular_core.WritableSignal<MatDialogRef<any, any>>;
    /** Subscription for closed events */
    protected closedSub: Subscription;
    /** Subscription for opened events */
    protected openedSub: Subscription;
    /** Signal indicating whether the modal is open */
    protected readonly isOpened: _angular_core.WritableSignal<boolean>;
    /** Template reference for the body content when using lazy loading */
    bodyTemplateRef: TemplateRef<any>;
    /** Template reference for the footer content when using lazy loading */
    footerTemplateRef: TemplateRef<any>;
    /** Content child directive for the modal body */
    bodyTemplate: _angular_core.Signal<ModalBodyDirective>;
    /** Content child directive for the modal footer */
    footerTemplate: _angular_core.Signal<ModalFooterDirective>;
    protected readonly service: ModalService;
    protected readonly dr: DestroyRef;
    protected readonly uS: UtilityService;
    protected readonly onDestroy: () => void;
    readonly serviceConfig: _angular_core.Signal<MatDialogConfig<any>>;
    readonly config: _angular_core.WritableSignal<{
        viewContainerRef?: _angular_core.ViewContainerRef;
        injector?: _angular_core.Injector;
        id?: string;
        role?: _angular_material_dialog.DialogRole;
        panelClass?: string | string[];
        hasBackdrop?: boolean;
        backdropClass?: string | string[];
        disableClose: boolean;
        closePredicate?: <Result = unknown, Component = unknown, Config extends _angular_cdk_dialog.DialogConfig = MatDialogConfig>(result: Result | undefined, config: Config, componentInstance: Component | null) => boolean;
        width: string;
        height: string;
        minWidth?: number | string;
        minHeight?: number | string;
        maxWidth?: number | string;
        maxHeight?: number | string;
        position?: _angular_material_dialog.DialogPosition;
        data?: any;
        direction?: _angular_cdk_bidi.Direction;
        ariaDescribedBy?: string | null;
        ariaLabelledBy?: string | null;
        ariaLabel?: string | null;
        ariaModal?: boolean;
        autoFocus?: _angular_material_dialog.AutoFocusTarget | string | boolean;
        restoreFocus?: boolean;
        delayFocusTrap?: boolean;
        scrollStrategy?: _angular_cdk_overlay.ScrollStrategy;
        closeOnNavigation?: boolean;
        enterAnimationDuration?: string | number;
        exitAnimationDuration?: string | number;
    }>;
    /**
     * Opens the modal with the specified configuration
     * @param args - Additional arguments for opening the modal
     */
    open(...args: any[]): void;
    /**
     * Closes the modal with optional data
     * @param data - Data to pass to the close event
     */
    close(data?: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "modal-comp", never, { "isFullscreen": { "alias": "isFullscreen"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "_showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; "_showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "bodyTemplateRef": { "alias": "bodyTemplateRef"; "required": false; }; "footerTemplateRef": { "alias": "footerTemplateRef"; "required": false; }; }, { "onClose": "onClose"; }, ["bodyTemplate", "footerTemplate"], ["[body]", "[footer]"], true, never>;
}
/**
 * Global configuration for modals
 */
declare const modalGeneralConfig: {
    /** Function to call when a modal is opened */
    onOpenFunction: (modal: ModalComponent) => void;
};

/**
 * Interface for upload response
 * @remarks
 * This interface defines the structure of the response received after a successful file upload.
 */
interface IUploadResponse {
    /** Unique identifier for the uploaded file */
    id: string;
    /** Name of the uploaded file */
    filename: string;
}

/**
 * Component for importing items from files
 * @remarks
 * This component provides functionality to upload and process files (CSV, Excel) for importing items.
 * It supports drag-and-drop, file selection, and progress tracking.
 *
 * @example
 * ```html
 * <import-items
 *   [header]="'Import Users'"
 *   [templatePath]="'/assets/templates/users.csv'"
 *   [uploadFunc]="handleUpload">
 * </import-items>
 * ```
 */
declare class ImportItemsComponent {
    uS: UtilityService;
    /**
     * Reference to the modal component
     */
    modal: ModalComponent;
    /**
     * Header text for the import dialog
     */
    header: string;
    /**
     * Path to the template file
     */
    templatePath: string;
    /**
     * Label for the file input
     */
    label: string;
    /**
     * Function to handle file upload
     */
    uploadFunc: (file: File) => Observable<{
        body?: {
            data: IUploadResponse;
        };
        progress?: number;
        uploaded?: boolean;
    }>;
    /**
     * Loading state
     */
    loading: boolean;
    /**
     * Initializes the component
     * @throws Error if upload function is not provided
     */
    ngOnInit(): void;
    /**
     * Opens the import dialog
     */
    open(): void;
    /**
     * Closes the import dialog
     */
    close(): void;
    /**
     * Downloads the template file
     */
    downloadTemplate(): void;
    /**
     * Accepted file types for upload
     */
    acceptedTypes: string[];
    /**
     * Opens the file selection dialog
     * @param loader - Loader component for progress indication
     */
    openFileDialog(loader: LoaderComponent): void;
    /**
     * Uploads and processes the selected file
     * @param file - File to upload
     * @param loader - Loader component for progress indication
     */
    uploadFile(file: File, loader: LoaderComponent): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImportItemsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImportItemsComponent, "import-items", never, { "header": { "alias": "header"; "required": false; }; "templatePath": { "alias": "templatePath"; "required": false; }; "label": { "alias": "label"; "required": false; }; "uploadFunc": { "alias": "uploadFunc"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for handling OTP (One-Time Password) input
 * @remarks
 * This component provides a multi-field input for OTP codes with validation and paste support.
 * It extends the basic input component to provide OTP-specific functionality.
 *
 * @example
 * ```html
 * <app-otp-input
 *   [otpLength]="6"
 *   [control]="otpControl"
 * ></app-otp-input>
 * ```
 */
declare class OtpInputComponent<TFormGroup extends {
    [K in keyof TFormGroup]: AbstractControl<any, any>;
} = any> extends InputBasicComponent<TFormGroup> {
    /** Form array containing individual OTP digit controls */
    subForm: FormArray<FormControl<string>>;
    /** Length of the OTP code */
    otpLength?: number;
    /**
     * Sets the OTP length and generates the form controls
     * @param v - The length of the OTP code
     */
    set _otpLength(v: number);
    /** Reference to all OTP input elements */
    otpInputRef: QueryList<ElementRef<HTMLInputElement>>;
    readonly subvalueEffect: _angular_core.EffectRef;
    /**
     * Initializes the component and sets up form value change subscriptions
     */
    ngOnInit(): void;
    /**
     * Sets up paste handling for OTP inputs after view initialization
     */
    ngAfterViewInit(): void;
    /**
     * Generates form controls for OTP input
     * @param otpLength - The length of the OTP code
     */
    genForm(otpLength?: number): void;
    /**
     * Handles input changes for individual OTP digits
     * @param e - The input event
     * @param form - The form control being updated
     */
    onChange(e: any, form: FormControl): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OtpInputComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OtpInputComponent<any>, "app-otp-input", never, { "_otpLength": { "alias": "otpLength"; "required": true; }; }, {}, never, never, true, never>;
}

/**
 * Component for handling listing filters with a modal interface
 * @remarks
 * This component provides a modal-based interface for filtering list data. It maintains
 * a clone of the form to allow for canceling changes and provides methods for clearing,
 * searching, and refreshing the filters.
 *
 * @example
 * ```html
 * <lib-listing-filters [form]="filterForm">
 *   <!-- Filter form content -->
 * </lib-listing-filters>
 * ```
 */
declare class ListingFiltersComponent {
    /** The main form group containing filter controls */
    form: FormGroup<any>;
    /**
     * Sets the form and creates a clone for canceling changes
     * @param v - The form group to set
     */
    set _form(v: FormGroup);
    /** Clone of the form for canceling changes */
    formClone: FormGroup;
    /** Reference to the modal component */
    modalRef: ModalComponent;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Closes the modal and optionally resets the form
     * @param noAction - If true, closes without any action
     */
    close(noAction?: boolean): void;
    /**
     * Clears all filters and closes the modal
     */
    clear(): void;
    /**
     * Applies the filters and closes the modal
     */
    search(): void;
    /**
     * Refreshes the filters by reapplying them
     */
    refresh(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingFiltersComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListingFiltersComponent, "lib-listing-filters", never, { "_form": { "alias": "form"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Component for displaying a mini modal that positions itself relative to a parent element
 * @remarks
 * This component extends the base ModalComponent to provide a smaller, context-aware modal
 * that positions itself relative to a specified parent element.
 *
 * @example
 * ```html
 * <mini-modal [height]="'300px'" [showFooter]="true">
 *   <!-- Modal content -->
 * </mini-modal>
 * ```
 */
declare class MiniModalComponent extends ModalComponent {
    /** Height of the modal, defaults to viewport height minus header */
    readonly height: _angular_core.InputSignal<string>;
    /** Whether to show the footer, defaults to true */
    readonly showFooter: _angular_core.InputSignal<boolean>;
    readonly config: _angular_core.WritableSignal<{
        viewContainerRef?: _angular_core.ViewContainerRef;
        injector?: _angular_core.Injector;
        id?: string;
        role?: _angular_material_dialog.DialogRole;
        panelClass: string | string[];
        hasBackdrop?: boolean;
        backdropClass: string | string[];
        disableClose: boolean;
        closePredicate?: <Result = unknown, Component = unknown, Config extends _angular_cdk_dialog.DialogConfig = MatDialogConfig>(result: Result | undefined, config: Config, componentInstance: Component | null) => boolean;
        width: string;
        height: string;
        minWidth?: number | string;
        minHeight?: number | string;
        maxWidth?: number | string;
        maxHeight: number | string;
        position?: _angular_material_dialog.DialogPosition;
        data?: any;
        direction?: _angular_cdk_bidi.Direction;
        ariaDescribedBy?: string | null;
        ariaLabelledBy?: string | null;
        ariaLabel?: string | null;
        ariaModal?: boolean;
        autoFocus?: _angular_material_dialog.AutoFocusTarget | string | boolean;
        restoreFocus?: boolean;
        delayFocusTrap?: boolean;
        scrollStrategy?: _angular_cdk_overlay.ScrollStrategy;
        closeOnNavigation?: boolean;
        enterAnimationDuration?: string | number;
        exitAnimationDuration?: string | number;
    }>;
    /**
     * Opens the modal and positions it relative to the specified parent element
     * @param parent - The element to position the modal relative to
     */
    open(parent: HTMLElement): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MiniModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MiniModalComponent, "mini-modal", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * Component for displaying a searchable list in a mini modal
 * @remarks
 * This component provides a searchable list interface within a mini modal,
 * allowing users to search and select items from a list.
 *
 * @example
 * ```html
 * <mini-search-list
 *   [list]="items"
 *   labelField="name"
 *   valueField="id"
 *   [header]="'Select Item'"
 *   (done)="onSelection($event)">
 * </mini-search-list>
 * ```
 */
declare class MiniSearchListComponent<TList = {
    value: string;
    label: string;
}> {
    /** List of items to display and search through */
    list: TList[];
    /** Field to use for item labels */
    labelField: keyof TList;
    /** Field to use for item values */
    valueField: keyof TList;
    /** Event emitted when an item is selected */
    _done: EventEmitter<any>;
    /** Header text for the modal */
    header: string;
    /** Currently selected item */
    selected: any;
    /**
     * Emits the selected item and closes the modal
     */
    done(): void;
    /** Reference to the mini modal component */
    mmCRef: MiniModalComponent;
    /** Form group containing the search input */
    form: FormGroup<{
        query: FormControl<string>;
    }>;
    /**
     * Opens the modal relative to the specified parent element
     * @param parent - The element to position the modal relative to
     */
    open(parent: HTMLElement): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MiniSearchListComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MiniSearchListComponent<any>, "mini-search-list", never, { "list": { "alias": "list"; "required": false; }; "labelField": { "alias": "labelField"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "header": { "alias": "header"; "required": false; }; }, { "_done": "done"; }, never, never, true, never>;
}

/**
 * Template component for modal forms
 * @remarks
 * This component serves as a template wrapper for modal forms, providing
 * the structure and common functionality for form-based modals.
 *
 * @example
 * ```html
 * <modal-form-template [comp]="formComponent">
 *   <!-- Form content -->
 * </modal-form-template>
 * ```
 */
declare class ModalFormTemplateComponent<TItem, TForm extends {
    [K in keyof TForm]: AbstractControl<any, any>;
} = any> {
    /** Reference to the parent modal form component */
    comp: ModalFormComponent<TItem, TForm>;
    /** Reference to the modal component */
    modal: ModalComponent;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFormTemplateComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalFormTemplateComponent<any, any>, "modal-form-template", never, { "comp": { "alias": "comp"; "required": false; }; }, {}, never, ["[afterForm]", "*"], true, never>;
}

/**
 * Component for handling form-based modals
 * @remarks
 * This component provides functionality for creating, editing, and viewing
 * items through a modal interface with form support.
 *
 * @example
 * ```html
 * <modal-form
 *   [form]="formGroup"
 *   [formFields]="formSchema"
 *   [header]="'Create Item'"
 *   [width]="'50%'"
 *   (onSaved)="onSave($event)">
 * </modal-form>
 * ```
 */
declare class ModalFormComponent<TItem, TForm extends {
    [K in keyof TForm]: AbstractControl<any, any>;
} = any> {
    /** Type of page being displayed (create, edit, or view) */
    pageType: EPageType;
    /** Form group containing the form controls */
    form: FormGroup<TForm>;
    /** Whether the form is in a loading state */
    loading: boolean;
    /** Header text for the modal */
    header: string;
    /** Width of the modal */
    width: string;
    /** Schema defining the form fields */
    formFields: IFormSchema[];
    /** Event emitted when the form is saved */
    onSaved: EventEmitter<TItem>;
    /** Reference to the modal form template */
    modal: ModalFormTemplateComponent<TItem, TForm>;
    /** Function to open the modal */
    protected open: (item?: TItem) => Promise<any>;
    /** Function to handle form submission */
    protected submitFunction: () => Promise<any>;
    ngAfterViewInit(): void;
    /**
     * Opens the modal in edit mode
     * @param item - The item to edit
     */
    openAsEdit(item: TItem): Promise<void>;
    /**
     * Opens the modal in create mode
     * @param defaultData - Default data for the new item
     */
    openAsCreate(defaultData?: any): Promise<void>;
    /**
     * Opens the modal in view mode
     * @param item - The item to view
     */
    openAsView(item: TItem): Promise<void>;
    /**
     * Prepares the modal for opening
     * @param pageType - The type of page to open
     */
    private prepareOpen;
    /**
     * Opens the form modal
     */
    private _openForm;
    /**
     * Cancels the form and resets it
     */
    cancel(): void;
    /**
     * Closes the modal and cancels the form
     */
    close(): void;
    /**
     * Submits the form
     * @param fc - Feedback card component for displaying messages
     * @param btn - Optional button component to show loading state
     */
    submit(fc: FeedbackCardComponent, btn?: BtnComponent): Promise<void>;
    /** Whether the form is in create mode */
    get isCreate(): boolean;
    /** Whether the form is in edit mode */
    get isEdit(): boolean;
    /** Whether the form is in view mode */
    get isShow(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFormComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalFormComponent<any, any>, "modal-form", never, {}, { "onSaved": "onSaved"; }, never, never, true, never>;
}

/**
 * Component for displaying modal headers
 * @remarks
 * This component provides a standardized header for modals, supporting both
 * text and template-based content, with built-in close functionality.
 *
 * @example
 * ```html
 * <modal-header
 *   [dialogRef]="dialogRef"
 *   [header]="'Modal Title'"
 *   [headerTemplate]="headerTemplate"
 *   [onCloseValue]="closeData">
 * </modal-header>
 * ```
 */
declare class ModalHeaderComponent implements OnInit {
    /** Reference to the dialog */
    readonly dialogRef: _angular_core.InputSignal<MatDialogRef<any, any>>;
    /** Header text */
    readonly header: _angular_core.InputSignal<string>;
    /** Custom header template */
    readonly headerTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Value to pass to the close function */
    readonly onCloseValue: _angular_core.InputSignal<any>;
    constructor();
    ngOnInit(): void;
    /**
     * Closes the modal with the specified value
     */
    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; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; "isSignal": true; }; "onCloseValue": { "alias": "onCloseValue"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * Base component for displaying data in a table
 * @remarks
 * This component provides a foundation for displaying tabular data with features like:
 * - Pagination
 * - Sorting
 * - Filtering
 * - Row selection
 * - Custom cell templates
 * - Responsive design
 *
 * @example
 * ```html
 * <table-plain
 *   [displayedColumns]="columns"
 *   [data]="items"
 *   [showPager]="true"
 *   [showFilter]="true"
 * ></table-plain>
 * ```
 */
declare class TablePlainComponent<TRow> implements OnInit {
    uS: UtilityService;
    /**
     * The label text for the table
     */
    readonly text: _angular_core.InputSignal<string>;
    /**
     * Array of row options for each row
     */
    readonly rowOptions: _angular_core.InputSignal<IRowOption<TRow>[]>;
    /**
     * Map of row options for each row
     */
    readonly rowOptionsMap: _angular_core.InputSignal<IRowOptionMap<TRow>>;
    /**
     * Whether to center cells in the table
     * @default false
     */
    readonly centerCells: _angular_core.InputSignal<boolean>;
    /**
     * Whether to use curved borders
     * @default false
     */
    readonly curvy: _angular_core.InputSignal<boolean>;
    /**
     * Array of columns to display in the table
     */
    readonly _displayedColumns: _angular_core.InputSignal<TableCol<TRow, {
        value: string;
        label: string;
    }>[]>;
    /**
     * Computed array of displayed columns with ignored columns filtered out
     */
    readonly clonedDisplayedColumns: _angular_core.Signal<TableCol<TRow, {
        value: string;
        label: string;
    }>[]>;
    /**
     * Map of custom templates for specific columns
     */
    readonly customTemplates: _angular_core.InputSignal<{ [x in keyof TRow]?: TemplateRef<any>; }>;
    /**
     * Computed array of displayed columns with mobile responsiveness
     */
    readonly displayedColumns: _angular_core.Signal<TableCol<TRow, {
        value: string;
        label: string;
    }>[]>;
    /**
     * Whether to show distinct values only
     * @default true
     */
    readonly distinct: _angular_core.InputSignal<boolean>;
    /**
     * Whether to allow single selection only
     */
    readonly singleSelection: _angular_core.InputSignal<boolean>;
    /**
     * The label for the table
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * Whether to format column headers
     * @default true
     */
    readonly formatColumnHeaders: _angular_core.InputSignal<boolean>;
    /**
     * The field to use as the ID for rows
     * @default 'id'
     */
    readonly idField: _angular_core.InputSignal<string>;
    /**
     * Text to display when no items are present
     * @default 'There are no items here...'
     */
    readonly noItemTxt: _angular_core.InputSignal<string>;
    /**
     * Whether to prevent text wrapping
     * @default true
     */
    readonly nowrap: _angular_core.InputSignal<boolean>;
    /**
     * The direction to sort by
     * @default 'asc'
     */
    readonly orderDirection: _angular_core.InputSignal<SortType>;
    /**
     * The field to sort by
     */
    readonly orderField: _angular_core.InputSignal<keyof TRow>;
    /**
     * Number of items per page
     * @default 5 on mobile, 10 on desktop
     */
    readonly pageSize: _angular_core.InputSignal<number>;
    /**
     * Available page size options
     * @default [5, 10, 15, 20, 50, 100, 200]
     */
    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
    /**
     * Whether to place selection checkboxes at the right
     * @default false
     */
    readonly placeSelectionAtRight: _angular_core.InputSignal<boolean>;
    /**
     * Total number of results
     * @default 0
     */
    resultsLength: number;
    /**
     * Whether to show export functionality
     * @default false
     */
    showExport: boolean;
    /**
     * Whether to enable row checking
     */
    readonly rowCheck: _angular_core.InputSignal<boolean>;
    /**
     * Field to use for row class
     */
    readonly rowClassField: _angular_core.InputSignal<string>;
    /**
     * Function to determine row class
     */
    readonly rowClassMap: _angular_core.InputSignal<(row: TRow) => string>;
    /**
     * Whether to show filter functionality
     * @default false
     */
    readonly showFilter: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show pagination
     * @default false
     */
    readonly showPager: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show row pointer
     * @default false
     */
    readonly showRowPointer: _angular_core.InputSignal<boolean>;
    /**
     * Whether to use smaller fonts
     * @default false
     */
    readonly smallerFonts: _angular_core.InputSignal<boolean>;
    /**
     * Template for the start section
     */
    startSectionTemplate: TemplateRef<HTMLElement>;
    /**
     * Function to determine if a row is disabled
     */
    isDisabledFunc: (row: TRow) => boolean;
    /**
     * Whether to use row selection
     * @default false
     */
    readonly useSelection: _angular_core.InputSignal<boolean>;
    /**
     * Event emitted when a row is clicked
     */
    _rowClick: EventEmitter<TRow>;
    /**
     * Event emitted when a row is viewed
     */
    _view: EventEmitter<TRow>;
    /**
     * Event emitted when the list is mutated
     */
    listMutated: EventEmitter<TRow[]>;
    /**
     * Signal containing the table data
     */
    readonly data: _angular_core.WritableSignal<TRow[]>;
    /**
     * Computed selection model
     */
    readonly selection: _angular_core.Signal<SelectionModel<TRow>>;
    /**
     * Observable of selection changes
     */
    readonly selection$: rxjs.Observable<SelectionModel<TRow>>;
    /**
     * Signal of selected items
     */
    readonly selectedSignal: _angular_core.Signal<TRow[]>;
    /**
     * Output of selection changes
     */
    readonly selectionChanged: _angular_core.OutputRef<SelectionChange<TRow>>;
    /**
     * Whether any items are selected
     */
    readonly isAnySelected: _angular_core.Signal<boolean>;
    /**
     * Data source for the table
     */
    dataSource: MatTableDataSource<TRow>;
    /**
     * Default filter predicate
     */
    defaultFilterPredicate: any;
    /**
     * Form group for filtering
     */
    form: FormGroup<{
        field: FormControl<any>;
        value: FormControl<any>;
    }>;
    /**
     * Reference to the paginator
     */
    paginator: MatPaginator;
    /**
     * Reference to the sort
     */
    sort: MatSort;
    /**
     * Event emitted when a checkbox is changed
     */
    emitCheckbox: EventEmitter<{
        field: string;
        item: TRow;
        value: boolean;
    }>;
    /**
     * Setter for table data
     * @param v - The data to set
     */
    set _data(v: TRow[]);
    /**
     * Computed array of row options
     */
    readonly crowOptions: _angular_core.Signal<IRowOption<TRow>[]>;
    /**
     * Whether row options are available
     */
    readonly hasRowOptions: _angular_core.Signal<boolean>;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Computed array of filter options
     */
    readonly filterOptions: _angular_core.Signal<{
        code: keyof TRow;
        description: string;
    }[]>;
    /**
     * Clears the current filter
     */
    clearFilter(): void;
    /**
     * Gets the row options for a specific row
     * @param row - The row to get options for
     * @returns Array of row options
     */
    formOptionsMap: (row: TRow) => IRowOption<TRow>[];
    /**
     * Whether all items are selected
     */
    readonly isAllSelected: _angular_core.Signal<boolean>;
    /**
     * Whether selection is indeterminate
     */
    readonly isIndeterminate: _angular_core.Signal<boolean>;
    /**
     * Toggles selection of all items
     */
    masterToggle(): void;
    /**
     * Toggles selection of a specific row
     * @param row - The row to toggle
     */
    toggleSelection(row: TRow): void;
    /**
     * Gets the selected items
     */
    get selectedItems(): TRow[];
    /**
     * Handles row click event
     * @param row - The clicked row
     */
    rowClick(row: any): void;
    /**
     * Handles button click in a cell
     * @param col - The column definition
     * @param row - The row data
     * @param index - The row index
     * @param btn - The button component
     */
    clickBtn(col: ITableCol, row: TRow, index: any, btn: BtnComponent): void;
    /**
     * Gets the action status callback for a column
     * @param col - The column definition
     * @returns Callback function for action status
     */
    getActionStatusCallback(col: any): (state: boolean) => boolean;
    /**
     * Increment for page size changes
     * @default 10
     */
    protected pageSizeIncrementor: number;
    /**
     * Increases the page size
     */
    increasePageSize(): void;
    /**
     * Decreases the page size
     */
    decreasePageSize(): void;
    /**
     * Resets the page size to default
     */
    resetPageSize(): void;
    /**
     * Gets the label for a row option
     * @param option - The row option
     * @param row - The row data
     * @returns The formatted label
     */
    optionLabeller: (option: IRowOption, row: TRow) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablePlainComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TablePlainComponent<any>, "table-plain", never, { "text": { "alias": "label"; "required": false; "isSignal": true; }; "rowOptions": { "alias": "rowOptions"; "required": false; "isSignal": true; }; "rowOptionsMap": { "alias": "rowOptionsMap"; "required": false; "isSignal": true; }; "centerCells": { "alias": "centerCells"; "required": false; "isSignal": true; }; "curvy": { "alias": "curvy"; "required": false; "isSignal": true; }; "_displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "customTemplates": { "alias": "customTemplates"; "required": false; "isSignal": true; }; "distinct": { "alias": "distinct"; "required": false; "isSignal": true; }; "singleSelection": { "alias": "singleSelection"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "formatColumnHeaders": { "alias": "formatColumnHeaders"; "required": false; "isSignal": true; }; "idField": { "alias": "idField"; "required": false; "isSignal": true; }; "noItemTxt": { "alias": "noItemTxt"; "required": false; "isSignal": true; }; "nowrap": { "alias": "nowrap"; "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; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "placeSelectionAtRight": { "alias": "placeSelectionAtRight"; "required": false; "isSignal": true; }; "resultsLength": { "alias": "resultsLength"; "required": false; }; "showExport": { "alias": "showExport"; "required": false; }; "rowCheck": { "alias": "rowCheck"; "required": false; "isSignal": true; }; "rowClassField": { "alias": "rowClassField"; "required": false; "isSignal": true; }; "rowClassMap": { "alias": "rowClassMap"; "required": false; "isSignal": true; }; "showFilter": { "alias": "showFilter"; "required": false; "isSignal": true; }; "showPager": { "alias": "showPager"; "required": false; "isSignal": true; }; "showRowPointer": { "alias": "showRowPointer"; "required": false; "isSignal": true; }; "smallerFonts": { "alias": "smallerFonts"; "required": false; "isSignal": true; }; "startSectionTemplate": { "alias": "startSectionTemplate"; "required": false; }; "isDisabledFunc": { "alias": "isDisabledFunc"; "required": false; }; "useSelection": { "alias": "useSelection"; "required": false; "isSignal": true; }; "_data": { "alias": "data"; "required": false; }; }, { "_rowClick": "rowClick"; "_view": "view"; "listMutated": "listMutated"; "selectionChanged": "selectionChanged"; "emitCheckbox": "emitCheckbox"; }, never, never, true, never>;
}

/**
 * Component for displaying data in a table with HTTP data fetching capabilities
 * @remarks
 * This component extends TablePlainComponent to add HTTP data fetching functionality.
 * It supports pagination, sorting, filtering, and real-time data updates.
 *
 * @example
 * ```html
 * <table-https
 *   [header]="'Users'"
 *   [queryData]="queryParams"
 *   [observableFunc]="getUsers"
 *   [showRefreshBtn]="true"
 * ></table-https>
 * ```
 */
declare class TableHttpsComponent<TItem = any> extends TablePlainComponent<TItem> implements OnInit {
    readonly route: ActivatedRoute;
    readonly pSS: PatchSdkService;
    readonly getExportLater: _angular_core.InputSignal<boolean>;
    /**
     * The header text to display above the table
     */
    header: string;
    /**
     * The subtitle to display when no data is available
     */
    readonly noDataSubTitle: _angular_core.InputSignal<string>;
    /**
     * Array of buttons to display in the header
     */
    readonly headerBtns: _angular_core.InputSignal<IBtn<(...args: any[]) => void>[]>;
    /**
     * Whether to show the refresh button
     * @default false
     */
    showRefreshBtn: boolean;
    /**
     * Query parameters for data fetching
     */
    queryData: IObjectLiteral;
    /**
     * Required function that returns an Observable for fetching table data
     * @param data - The query parameters for the data fetch
     * @returns Observable of ITableSearchFunc containing the fetched data
     */
    readonly observableFunc: _angular_core.InputSignal<(data: any) => Observable<ITableSearchFunc<any>>>;
    /**
     * Observable stream of the observableFunc
     */
    readonly observableFunc$: Observable<(data: any) => Observable<ITableSearchFunc<any>>>;
    /**
     * Current page number
     * @default 0
     */
    readonly pageNumber: _angular_core.InputSignal<number>;
    /**
     * Event emitted when total count is fetched
     */
    totalOnDataFetched: EventEmitter<number>;
    /**
     * Setter for refreshing data
     * @param v - Any value to trigger refresh
     */
    set refreshData(v: any);
    /**
     * Observable of filtered and paginated results
     */
    filteredAndPagedResults: Observable<any[]>;
    /**
     * Signal indicating if results are currently loading
     */
    readonly isLoadingResults: _angular_core.WritableSignal<boolean>;
    /**
     * Flag indicating if rate limit has been reached
     */
    isRateLimitReached: boolean;
    /**
     * BehaviorSubject containing the fetched data
     */
    fetchedData: BehaviorSubject<TItem[]>;
    /**
     * Contains all the search query parameters from the last fetch
     */
    allQuery: any;
    /**
     * Reference to the MatTable instance
     */
    table: MatTable<TItem>;
    readonly form2: FormGroup<{
        page: FormControl<number>;
        sortByField: FormControl<any>;
        sortByDirection: FormControl<string>;
        limit: FormControl<any>;
    }>;
    /**
     * Subject for triggering searches
     */
    searchTrigger: ReplaySubject<unknown>;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Triggers a search with optional query parameters
     * @param query - Optional query parameters for the search
     */
    search(query?: any): void;
    /**
     * Resets the pagination to the first page
     */
    resetPaging(): void;
    /**
     * Resets the table state
     */
    reset(): void;
    /**
     * Refreshes the table data
     */
    refresh(): void;
    /**
     * Sets the table data directly
     * @param d - The data to set
     */
    setData(d: TItem[]): void;
    increasePageSize(): void;
    resetPageSize(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableHttpsComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableHttpsComponent<any>, "table-https", never, { "getExportLater": { "alias": "getExportLater"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; }; "noDataSubTitle": { "alias": "noDataSubTitle"; "required": false; "isSignal": true; }; "headerBtns": { "alias": "headerBtns"; "required": false; "isSignal": true; }; "showRefreshBtn": { "alias": "showRefreshBtn"; "required": false; }; "queryData": { "alias": "queryData"; "required": false; }; "observableFunc": { "alias": "observableFunc"; "required": true; "isSignal": true; }; "pageNumber": { "alias": "pageNumber"; "required": false; "isSignal": true; }; "refreshData": { "alias": "refreshData"; "required": false; }; }, { "totalOnDataFetched": "totalOnDataFetched"; }, never, never, true, never>;
}
/**
 * Interface for table search function response
 */
interface ITableSearchFunc<T = any> {
    /**
     * Array of data items
     */
    data: T[];
    /**
     * Total count of items
     */
    total: number;
}

/**
 * Service for managing find item component configuration
 * @remarks
 * This service provides configuration management for the find item component,
 * including settings for borders, validation messages, and button types.
 *
 * @example
 * ```typescript
 * constructor(private findItemService: FindItemService) {
 *   this.findItemService.updateConfig({
 *     useBorder: false,
 *     showValidationMsg: true
 *   });
 * }
 * ```
 */
declare class FindItemService {
    /**
     * Signal containing the current configuration
     * @remarks
     * Default configuration includes:
     * - useBorder: true
     * - showValidationMsg: true
     * - clearButtonType: 'danger-outline'
     * - createButtonType: 'outline'
     */
    protected readonly _config: _angular_core.WritableSignal<IConfig>;
    /**
     * Computed value of the current configuration
     */
    readonly config: _angular_core.Signal<IConfig>;
    constructor();
    /**
     * Updates the configuration with new values
     * @param val - Partial configuration object with new values
     */
    updateConfig(val: Partial<IConfig>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FindItemService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FindItemService>;
}
/**
 * Interface for find item configuration
 */
type IConfig = {
    /**
     * Whether to show refresh button
     */
    showRefreshBtn?: boolean;
    /**
     * Whether to show validation messages
     */
    showValidationMsg?: boolean;
    /**
     * Whether to use border styling
     */
    useBorder?: boolean;
    /**
     * Whether to show export button
     */
    showExport?: boolean;
    /**
     * Type of clear button
     */
    clearButtonType?: BtnType;
    /**
     * Type of search button
     */
    searchButtonType?: BtnType;
    /**
     * Type of create button
     */
    createButtonType?: BtnType;
};

declare class FindItemComponent<TQuery extends IObjectLiteral = any, TRow extends IObjectLiteral = any> implements OnInit {
    readonly service: FindItemService;
    uS: UtilityService;
    destroyRef: DestroyRef;
    router: Router;
    route: ActivatedRoute;
    /**
     * Whether to sort schema
     */
    autoFormatSchema: boolean;
    autoOrder: boolean;
    readonly _distinct: _angular_core.InputSignal<any>;
    readonly distinct: _angular_core.Signal<boolean>;
    centerCells: boolean;
    readonly displayedColumns: _angular_core.InputSignal<TableCol<TRow, {
        value: string;
        label: string;
    }>[]>;
    readonly customTemplates: _angular_core.InputSignal<{ [x in keyof TRow]?: TemplateRef<any>; }>;
    /**
     * Row grid configuration
     */
    readonly gridClass: _angular_core.InputSignal<string>;
    hideForm: boolean;
    expandedRowTemplate: TemplateRef<any>;
    readonly _isTablePaginated: _angular_core.InputSignal<boolean>;
    readonly isTablePaginated: _angular_core.Signal<boolean>;
    isExpandable: boolean;
    readonly showRowPointer: _angular_core.InputSignal<boolean>;
    readonly rowCheck: _angular_core.InputSignal<boolean>;
    label: string;
    nowrap: boolean;
    readonly singleSelection: _angular_core.InputSignal<boolean>;
    readonly getExportLater: _angular_core.InputSignal<boolean>;
    readonly rowOptions: _angular_core.InputSignal<IRowOption<TRow>[]>;
    readonly rowOptionsMap: _angular_core.InputSignal<IRowOptionMap<TRow>>;
    orderDirection: SortType;
    orderField: _angular_core.InputSignal<keyof TRow>;
    pageSize: number;
    readonly rowClassMap: _angular_core.InputSignal<(row: TRow) => string>;
    searchFunction: (data: any) => Observable<TRow[] | {
        content: TRow[];
    }>;
    readonly showData: _angular_core.InputSignal<boolean>;
    readonly _showExport: _angular_core.InputSignal<any>;
    readonly showExport: _angular_core.Signal<boolean>;
    showFilter: boolean;
    readonly _showRefreshBtn: _angular_core.InputSignal<any>;
    readonly showRefreshBtn: _angular_core.Signal<boolean>;
    startSectionTemplate: TemplateRef<HTMLElement>;
    form: FormGroup;
    /**
     * Used to specify if the search button should be shown
     */
    readonly showSearchBtn: _angular_core.InputSignal<boolean>;
    readonly gridContainerClass: _angular_core.ModelSignal<string>;
    readonly centerAlign: _angular_core.ModelSignal<boolean>;
    readonly verticalGrid: _angular_core.InputSignal<boolean>;
    readonly cGridClass: _angular_core.Signal<string>;
    readonly hasDisplayedColumns: _angular_core.Signal<boolean>;
    readonly hideTable: _angular_core.Signal<boolean>;
    readonly cShowSearchBtn: _angular_core.Signal<boolean>;
    /**
     * Used to specify if the clear form button should be shown
     */
    showClearBtn: boolean;
    /**
     * Used to specify if validation messages should be shown
     */
    readonly _showValidationMsg: _angular_core.InputSignal<boolean>;
    readonly gridAlignment: _angular_core.InputSignal<string>;
    readonly showValidationMsg: _angular_core.Signal<boolean>;
    /**
     * Used to specify if show additional column button wiil be displayed or not.
     */
    showAdditionalColumns: boolean;
    smallerFonts: boolean;
    readonly center: _angular_core.InputSignal<boolean>;
    readonly debug: _angular_core.InputSignal<boolean>;
    readonly realtimeSearch: _angular_core.InputSignal<boolean>;
    /** Use checkboxes */
    useSelection: boolean;
    cellOptions: IFormOptions$1;
    _rowClick: EventEmitter<any>;
    tableHTTPSREF: TableHttpsComponent<TRow>;
    tablePlainRef: TablePlainComponent<TRow>;
    readonly data: _angular_core.WritableSignal<TRow[]>;
    readonly formSchema: _angular_core.WritableSignal<ISearchFormSchema<TQuery>[]>;
    readonly loading: _angular_core.WritableSignal<boolean>;
    readonly searchForm: FormGroup;
    readonly standaloneForm: FormGroup;
    readonly feedbackCardRef: _angular_core.Signal<FeedbackCardComponent>;
    /**
     * Used to specify if show create button is needed.
     */
    createButton: boolean;
    readonly createButtonRoute: _angular_core.InputSignal<string>;
    set _formSchema(v: ISearchFormSchema<TQuery>[]);
    readonly searchObservableFunc: _angular_core.InputSignal<(data: any) => Observable<ITableSearchFunc<TRow>>>;
    readonly delimiterField = "~~~";
    readonly delimiterWord = "~~";
    protected subs: {
        fieldName: string;
        sub: Subscription;
    }[];
    protected readonly searchTrigger: Subject<number>;
    readonly searchTriggerEvent: _angular_core.OutputRef<any>;
    readonly selectionSignal: _angular_core.WritableSignal<TRow[]>;
    readonly isAnySelected: _angular_core.Signal<boolean>;
    readonly selectionChanged: _angular_core.OutputEmitterRef<TRow[]>;
    protected readonly subs2: {
        clear: () => void;
        push: (...subs: Subscription[]) => void;
    };
    readonly searchFormValue: _angular_core.Signal<any>;
    ngOnInit(): void;
    setSelectionChanged(event: SelectionChange<TRow>): void;
    onDestroy(): void;
    fieldAction(field: ISearchFormSchema): void;
    fetchSavedQuery(): void;
    init(schema: ISearchFormSchema<TQuery>[]): void;
    setFormSchema(schema: ISearchFormSchema<TQuery>[]): void;
    handleAllSchema(schema: ISearchFormSchema<TQuery>[]): ISearchFormSchema<TQuery>[];
    handleFormScheme(scheme: ISearchFormSchema<TQuery>): void;
    detachFormScheme(schemeIndex?: number, fieldName?: string): void;
    amendFormScheme: (fieldName: keyof TQuery, formScheme: Partial<ISearchFormSchema<{ [k in keyof TQuery]: AbstractControl<any, any> | any; }>>) => void;
    get allSearchFormValue(): any;
    trackByRowID: (index: any, item: any) => any;
    clearFilters(): void;
    refresh(): void;
    search(config?: {
        delay?: number;
    }): void;
    setLoader(loading: boolean): void;
    _search(): Promise<void>;
    saveQuery(query?: any): void;
    rowClick(e: any): void;
    get selection(): TRow[];
    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; }; "autoOrder": { "alias": "autoOrder"; "required": false; }; "_distinct": { "alias": "distinct"; "required": false; "isSignal": true; }; "centerCells": { "alias": "centerCells"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "customTemplates": { "alias": "customTemplates"; "required": false; "isSignal": true; }; "gridClass": { "alias": "gridClass"; "required": false; "isSignal": true; }; "hideForm": { "alias": "hideForm"; "required": false; }; "expandedRowTemplate": { "alias": "expandedRowTemplate"; "required": false; }; "_isTablePaginated": { "alias": "isTablePaginated"; "required": false; "isSignal": true; }; "isExpandable": { "alias": "isExpandable"; "required": false; }; "showRowPointer": { "alias": "showRowPointer"; "required": false; "isSignal": true; }; "rowCheck": { "alias": "rowCheck"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; }; "nowrap": { "alias": "nowrap"; "required": false; }; "singleSelection": { "alias": "singleSelection"; "required": false; "isSignal": true; }; "getExportLater": { "alias": "getExportLater"; "required": false; "isSignal": true; }; "rowOptions": { "alias": "rowOptions"; "required": false; "isSignal": true; }; "rowOptionsMap": { "alias": "rowOptionsMap"; "required": false; "isSignal": true; }; "orderDirection": { "alias": "orderDirection"; "required": false; }; "orderField": { "alias": "orderField"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; }; "rowClassMap": { "alias": "rowClassMap"; "required": false; "isSignal": true; }; "searchFunction": { "alias": "searchFunction"; "required": false; }; "showData": { "alias": "showData"; "required": false; "isSignal": true; }; "_showExport": { "alias": "showExport"; "required": false; "isSignal": true; }; "showFilter": { "alias": "showFilter"; "required": false; }; "_showRefreshBtn": { "alias": "showRefreshBtn"; "required": false; "isSignal": true; }; "startSectionTemplate": { "alias": "startSectionTemplate"; "required": false; }; "showSearchBtn": { "alias": "showSearchBtn"; "required": false; "isSignal": true; }; "gridContainerClass": { "alias": "gridContainerClass"; "required": false; "isSignal": true; }; "centerAlign": { "alias": "centerAlign"; "required": false; "isSignal": true; }; "verticalGrid": { "alias": "verticalGrid"; "required": false; "isSignal": true; }; "showClearBtn": { "alias": "showClearBtn"; "required": false; }; "_showValidationMsg": { "alias": "showValidationMsg"; "required": false; "isSignal": true; }; "gridAlignment": { "alias": "gridAlignment"; "required": false; "isSignal": true; }; "showAdditionalColumns": { "alias": "showAdditionalColumns"; "required": false; }; "smallerFonts": { "alias": "smallerFonts"; "required": false; }; "center": { "alias": "center"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "realtimeSearch": { "alias": "realtimeSearch"; "required": false; "isSignal": true; }; "useSelection": { "alias": "useSelection"; "required": false; }; "createButton": { "alias": "createButton"; "required": false; }; "createButtonRoute": { "alias": "createButtonRoute"; "required": false; "isSignal": true; }; "_formSchema": { "alias": "formSchema"; "required": false; }; "searchObservableFunc": { "alias": "searchObservableFunc"; "required": false; "isSignal": true; }; }, { "gridContainerClass": "gridContainerClassChange"; "centerAlign": "centerAlignChange"; "_rowClick": "rowClick"; "searchTriggerEvent": "searchTriggerEvent"; "selectionChanged": "selectionChanged"; }, never, ["[tablePanel]"], true, never>;
}
interface ISearchFormSchema<TQuery extends IObjectLiteral = any> extends IFormSchema2<TQuery> {
    standalone?: boolean;
    triggerOnChangeOnInit?: boolean;
    onChangeFuncSF?: (formValue: TQuery, _this?: FindItemComponent<TQuery>, inp?: InputBasicComponent) => any;
    action?: (formValue: TQuery, cell: any, form?: FormGroup<IStrictFormGroup<TQuery>>) => any;
}

declare class ContentPaginatorComponent<TRow> {
    readonly pSS: PatchSdkService;
    /**
     * Row grid configuration
     */
    readonly gridClass: _angular_core.InputSignal<string>;
    readonly searchFunction: _angular_core.InputSignal<(data: any) => Observable<{
        total: number;
        data: TRow[];
    }>>;
    readonly bodyTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly sortOptions: _angular_core.InputSignal<ISortOptionsListItem<TRow>[]>;
    readonly pageNumber: _angular_core.InputSignal<number>;
    readonly header: _angular_core.InputSignal<string>;
    readonly queryData: _angular_core.InputSignal<IObjectLiteral>;
    readonly showRefreshBtn: _angular_core.InputSignal<boolean>;
    readonly realtimeSearch: _angular_core.InputSignal<boolean>;
    readonly searchFormSchema: _angular_core.InputSignal<ISearchFormSchema<any>[]>;
    readonly eff: _angular_core.EffectRef;
    readonly orderDirection: _angular_core.ModelSignal<SortType>;
    readonly orderField: _angular_core.ModelSignal<keyof TRow>;
    readonly pageSize: _angular_core.InputSignal<number>;
    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
    protected readonly showSorter: _angular_core.Signal<boolean>;
    protected readonly csortOptions: _angular_core.Signal<{
        isAscending: boolean;
        _id: string;
        field: keyof TRow;
        label: string;
        order: SortType;
    }[]>;
    protected readonly _isLoadingResults: _angular_core.WritableSignal<boolean>;
    readonly isLoadingResults: _angular_core.Signal<boolean>;
    readonly showSearchForm: _angular_core.Signal<boolean>;
    protected readonly _selectedSortOptionIndex: _angular_core.WritableSignal<number>;
    readonly selectedSortOptionIndex: _angular_core.Signal<number>;
    readonly sortValue: _angular_core.Signal<{
        field: keyof TRow;
        order: SortType;
    }>;
    protected readonly searchTrigger: Subject<unknown>;
    protected readonly order$: Observable<{
        field: keyof TRow;
        order: SortType;
    }>;
    readonly findItemCompRef: _angular_core.Signal<FindItemComponent<IObjectLiteral, IObjectLiteral>>;
    readonly searchCenterAlign: _angular_core.ModelSignal<boolean>;
    readonly searchGridContainerClass: _angular_core.ModelSignal<string>;
    protected readonly paginator: _angular_core.Signal<MatPaginator>;
    protected readonly paginatorValue$: Observable<{
        page: number;
        limit: number;
    }>;
    protected readonly paginatorValue: _angular_core.Signal<{
        page: number;
        limit: number;
    }>;
    readonly formQuery: _angular_core.WritableSignal<IObjectLiteral>;
    readonly allQuery: _angular_core.Signal<{
        [x: string]: any;
    }>;
    readonly allQuery$: Observable<IObjectLiteral | {
        [x: string]: any;
    }>;
    protected readonly response$: Observable<{
        total: number;
        data: TRow[];
    } | {
        data: any[];
        total: number;
    } | {
        data: any[];
        total: number;
    }>;
    readonly response: _angular_core.Signal<{
        total: number;
        data: TRow[];
    } | {
        data: any[];
        total: number;
    } | {
        data: any[];
        total: number;
    }>;
    readonly data: _angular_core.Signal<TRow[]>;
    readonly total: _angular_core.Signal<number>;
    readonly dataFetched: _angular_core.OutputRef<{
        queryData: {
            [x: string]: any;
        };
        field: keyof TRow;
        order: SortType;
        page: number;
        limit: number;
        total: number;
        data: TRow[];
    } | {
        queryData: {
            [x: string]: any;
        };
        field: keyof TRow;
        order: SortType;
        page: number;
        limit: number;
        data: any[];
        total: number;
    } | {
        queryData: {
            [x: string]: any;
        };
        field: keyof TRow;
        order: SortType;
        page: number;
        limit: number;
        data: any[];
        total: number;
    }>;
    selectSortOption(index: number): void;
    refresh(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContentPaginatorComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContentPaginatorComponent<any>, "content-paginator", never, { "gridClass": { "alias": "gridClass"; "required": false; "isSignal": true; }; "searchFunction": { "alias": "searchFunction"; "required": false; "isSignal": true; }; "bodyTemplate": { "alias": "bodyTemplate"; "required": false; "isSignal": true; }; "sortOptions": { "alias": "sortOptions"; "required": false; "isSignal": true; }; "pageNumber": { "alias": "pageNumber"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "queryData": { "alias": "queryData"; "required": false; "isSignal": true; }; "showRefreshBtn": { "alias": "showRefreshBtn"; "required": false; "isSignal": true; }; "realtimeSearch": { "alias": "realtimeSearch"; "required": false; "isSignal": true; }; "searchFormSchema": { "alias": "searchFormSchema"; "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; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "searchCenterAlign": { "alias": "searchCenterAlign"; "required": false; "isSignal": true; }; "searchGridContainerClass": { "alias": "searchGridContainerClass"; "required": false; "isSignal": true; }; }, { "orderDirection": "orderDirectionChange"; "orderField": "orderFieldChange"; "searchCenterAlign": "searchCenterAlignChange"; "searchGridContainerClass": "searchGridContainerClassChange"; "dataFetched": "dataFetched"; }, never, ["*"], true, never>;
}
interface ISortOptionsListItem<TRow> {
    field: keyof TRow;
    label: string;
    order: SortType;
}

/**
 * Service for managing icons
 * @remarks
 * This service handles the registration and management of SVG icons.
 * It provides functionality to register icons and check their registration status.
 */
declare class IconService {
    iconRegistry: MatIconRegistry;
    sanitizer: DomSanitizer;
    /**
     * Signal containing registered icons
     */
    protected readonly _icons: _angular_core.WritableSignal<(keyof herlhay_helpers.IconNames)[]>;
    /**
     * Computed value of registered icons
     */
    readonly icons: _angular_core.Signal<(keyof herlhay_helpers.IconNames)[]>;
    /**
     * Computed set of registered icons for quick lookup
     */
    readonly svgIconsIndex: _angular_core.Signal<Set<keyof herlhay_helpers.IconNames>>;
    /**
     * Registers multiple icons with the icon registry
     * @param icons - Array of icon names to register
     * @param config - Optional configuration including base path
     */
    registerIcons(icons: EIcon[], config?: {
        basePath?: string;
    }): void;
    /**
     * Checks if an icon is registered
     * @param icon - Icon name to check
     * @returns Whether the icon is registered
     */
    isRegistered(icon: string): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IconService>;
}

/**
 * Component for displaying icons
 * @remarks
 * This component provides a flexible way to display both Material icons and custom SVG icons.
 * It supports various sizing options and icon types.
 *
 * @example
 * ```html
 * <app-icon
 *   [icon]="'home'"
 *   [dimension]="'24px'">
 * </app-icon>
 * ```
 */
declare class IconComponent {
    iconService: IconService;
    /**
     * Image source for custom icons
     */
    readonly image: _angular_core.InputSignal<string>;
    /**
     * Material icon name
     */
    readonly icon: _angular_core.InputSignal<keyof IconNames>;
    /**
     * Additional CSS classes for the icon
     */
    readonly iconClass: _angular_core.InputSignal<string>;
    readonly matIcon: _angular_core.InputSignal<string>;
    /**
     * Default dimension for both width and height
     */
    readonly dimension: _angular_core.InputSignal<string>;
    /**
     * Custom height for the icon
     */
    readonly height: _angular_core.InputSignal<string>;
    /**
     * Computed height based on height or dimension input
     */
    readonly computedHeight: _angular_core.Signal<string>;
    /**
     * Custom width for the icon
     */
    readonly width: _angular_core.InputSignal<string>;
    /**
     * Computed width based on width or dimension input
     */
    readonly computedWidth: _angular_core.Signal<string>;
    /**
     * Whether the icon is registered in the icon service
     */
    readonly isRegistered: _angular_core.Signal<boolean>;
    /**
     * Computed icon value based on registration status
     */
    readonly computedValue: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "app-icon", never, { "image": { "alias": "image"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; "matIcon": { "alias": "matIcon"; "required": false; "isSignal": true; }; "dimension": { "alias": "dimension"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const ModalModule: (typeof ModalComponent | typeof ModalBodyDirective)[];

/**
 * Component for displaying a set of actions for a table row
 * @remarks
 * This component provides a set of buttons for common row actions like edit, delete, etc.
 * It can be used in tables or lists to provide row-level actions.
 *
 * @example
 * ```html
 * <row-actions
 *   [actions]="['edit', 'delete']"
 *   (actionClicked)="onAction($event)">
 * </row-actions>
 * ```
 */
declare class RowActionsComponent {
    clickedAdd: EventEmitter<{
        btn: BtnComponent;
    }>;
    clickedDelete: EventEmitter<{
        btn: BtnComponent;
    }>;
    clickedClone: EventEmitter<{
        btn: BtnComponent;
    }>;
    clickedSave: EventEmitter<{
        btn: BtnComponent;
    }>;
    readonly mini: _angular_core.InputSignal<boolean>;
    readonly isShow: _angular_core.InputSignal<boolean>;
    set _helpMap(v: HelpMap);
    readonly isVertical: _angular_core.WritableSignal<boolean>;
    readonly isHorizontal: _angular_core.WritableSignal<boolean>;
    set _isVertical(v: boolean);
    set _isHorizontal(v: boolean);
    readonly showSave: _angular_core.InputSignal<boolean>;
    readonly showClone: _angular_core.InputSignal<boolean>;
    readonly btns: _angular_core.InputSignal<IBtn<(...args: any[]) => void>[]>;
    protected saveBtn: IBtn;
    protected cloneBtn: IBtn;
    readonly computedBtns: _angular_core.Signal<IBtn<(...args: any[]) => void>[]>;
    readonly additionalBtns: _angular_core.InputSignal<IBtn<(...args: any[]) => void>[]>;
    readonly helpMap: _angular_core.WritableSignal<HelpMap>;
    constructor();
    /**
     * Handles action button click
     * @param action - The action that was clicked
     */
    onActionClick(action: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowActionsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowActionsComponent, "row-actions", never, { "mini": { "alias": "mini"; "required": false; "isSignal": true; }; "isShow": { "alias": "isShow"; "required": false; "isSignal": true; }; "_helpMap": { "alias": "helpMap"; "required": false; }; "_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; }; "additionalBtns": { "alias": "additionalBtns"; "required": false; "isSignal": true; }; }, { "clickedAdd": "clickedAdd"; "clickedDelete": "clickedDelete"; "clickedClone": "clickedClone"; "clickedSave": "clickedSave"; }, never, never, true, never>;
}
declare enum EActionType {
    add = "add",
    delete = "delete",
    clone = "clone",
    save = "save"
}
type HelpMap = {
    [typ in EActionType]?: string;
};

/**
 * Component for displaying a modal that slides in from the side of the screen
 * @remarks
 * This component extends the base ModalComponent to provide a side-sliding modal
 * that appears from the right side of the screen. On mobile devices, it behaves
 * like a regular modal.
 *
 * @example
 * ```html
 * <side-modal-comp [height]="'auto'" [showFooter]="true">
 *   <!-- Modal content -->
 * </side-modal-comp>
 * ```
 */
declare class SideModalComponent extends ModalComponent {
    /** Height of the modal, responsive to mobile view */
    readonly height: _angular_core.InputSignal<string>;
    /** Whether to show the footer, defaults to true */
    readonly showFooter: _angular_core.InputSignal<boolean>;
    readonly serviceConfig: _angular_core.Signal<MatDialogConfig<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SideModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SideModalComponent, "side-modal-comp", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; }, {}, never, ["[body]", "[footer]"], true, never>;
}

/**
 * Component for displaying a "no items" message with optional icon and action button
 * @remarks
 * This component provides a consistent way to display empty states in lists or tables.
 * It supports custom messages, icons, and action buttons.
 */
declare class NoListComponent {
    header: string;
    subheader: string;
    addBtnText: string;
    hideAddBtn: boolean;
    addButtonClicked: EventEmitter<boolean>;
    /**
     * The message to display when no items are present
     * @default 'No items found'
     */
    message: string;
    /**
     * The icon to display above the message
     * @default 'search'
     */
    icon: string;
    /**
     * Whether to show an action button
     * @default false
     */
    showAction: boolean;
    /**
     * The text to display on the action button
     * @default 'Add New'
     */
    actionText: string;
    /**
     * The icon to display on the action button
     * @default 'add'
     */
    actionIcon: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NoListComponent, "no-list", never, { "header": { "alias": "header"; "required": false; }; "subheader": { "alias": "subheader"; "required": false; }; "addBtnText": { "alias": "addBtnText"; "required": false; }; "hideAddBtn": { "alias": "hideAddBtn"; "required": false; }; "message": { "alias": "message"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "showAction": { "alias": "showAction"; "required": false; }; "actionText": { "alias": "actionText"; "required": false; }; "actionIcon": { "alias": "actionIcon"; "required": false; }; }, { "addButtonClicked": "addButtonClicked"; }, never, never, true, never>;
}

/**
 * Component for displaying and managing selected items count with edit/delete actions
 * @remarks
 * This component shows the number of selected items and provides buttons for edit and delete actions.
 *
 * @example
 * ```html
 * <number-items-selected
 *   [count]="5"
 *   [useEdit]="true"
 *   (onDelete)="handleDelete()"
 *   (onEdit)="handleEdit()">
 * </number-items-selected>
 * ```
 */
declare class NumberItemsSelectedComponent {
    /**
     * Number of items currently selected
     */
    count: number;
    /**
     * Whether to show the edit button
     * @default false
     */
    useEdit: boolean;
    /**
     * Event emitted when delete action is triggered
     */
    _onDelete: EventEmitter<boolean>;
    /**
     * Event emitted when edit action is triggered
     */
    _onEdit: EventEmitter<boolean>;
    constructor();
    /**
     * Emits delete event
     */
    onDelete(): void;
    /**
     * Emits edit event
     */
    onEdit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberItemsSelectedComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberItemsSelectedComponent, "number-items-selected", never, { "count": { "alias": "count"; "required": false; }; "useEdit": { "alias": "useEdit"; "required": false; }; }, { "_onDelete": "onDelete"; "_onEdit": "onEdit"; }, never, never, true, never>;
}

/**
 * Base component for page templates with common functionality
 * @remarks
 * This component provides a foundation for different page types (create, edit, show, etc.)
 * with built-in state management, routing, and modal support.
 *
 * @example
 * ```typescript
 * @Component({
 *   template: `<div>Custom page content</div>`
 * })
 * class CustomPageComponent extends PageTemplateComponent<CustomModel> {
 *   // Override methods as needed
 * }
 * ```
 */
declare class PageTemplateComponent<ModelData = any> {
    /**
     * Injected ActivatedRoute instance
     */
    route: ActivatedRoute;
    /**
     * Injected UtilityService instance
     */
    uS: UtilityService;
    /**
     * Injected ChangeDetectorRef instance
     */
    cdr: ChangeDetectorRef;
    /**
     * Injected Router instance
     */
    router: Router;
    /**
     * Signal indicating loading state
     * @default false
     */
    readonly loading: _angular_core.WritableSignal<boolean>;
    /**
     * Signal indicating modal state
     * @default false
     */
    readonly isModal: _angular_core.WritableSignal<boolean>;
    /**
     * Setter for modal state
     */
    set _isModal(v: boolean);
    /**
     * Input data for the component
     */
    modelData: ModelData;
    /**
     * Callback function for modal completion
     */
    modalOnComplete: (...args: any[]) => any;
    /**
     * Event emitted when modal is submitted
     */
    modalSubmitted: EventEmitter<any>;
    /**
     * ID field for the component
     */
    readonly id: _angular_core.WritableSignal<string>;
    /**
     * Signal for overriding page type
     */
    readonly overridePageTypeSignal: _angular_core.WritableSignal<EPageType>;
    /**
     * Getter for current page type
     */
    get pageType(): EPageType;
    /**
     * Setter for current page type
     */
    set pageType(value: EPageType);
    /**
     * Computed relative router
     */
    readonly relativeRouter: {
        route: ActivatedRoute;
        router: Router;
        navigate: (link: string, config?: i1$1.NavigationExtras | undefined) => Promise<boolean>;
        queryParams: i1$1.Params;
        pathParams: i1$1.Params;
    };
    /**
     * Computed value indicating if page is in create mode
     */
    readonly isCreate: _angular_core.Signal<boolean>;
    /**
     * Computed value indicating if page is in index mode
     */
    readonly isIndex: _angular_core.Signal<boolean>;
    /**
     * Computed value indicating if page is in clone mode
     */
    readonly isClone: _angular_core.Signal<boolean>;
    /**
     * Computed value indicating if page is in edit mode
     */
    readonly isEdit: _angular_core.Signal<boolean>;
    /**
     * Computed value indicating if page is in show mode
     */
    readonly isShow: _angular_core.Signal<boolean>;
    /**
     * Getter for info function from utility service
     */
    get infoFunc(): (text: string | unknown, status?: 0 | 2 | 1, heading?: string, btns?: herlhay_helpers.IInfoDialogBtn[], disableClose?: boolean) => Promise<boolean>;
    constructor();
    /**
     * Initializes the component
     * @param func - Optional async 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 for loading state
     */
    setLoader: (v: boolean) => void;
    /**
     * Computed page state object
     */
    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 query parameters
     */
    readonly queryParamsSignal: _angular_core.Signal<{
        id?: string;
    }>;
    /**
     * Getter for query parameters
     */
    get queryParams(): {
        id?: string;
    };
    /**
     * Checks if required parameters are present
     * @param params - Array of parameter names to check
     */
    checkParams(params?: string[]): Promise<void>;
    /**
     * Computed value indicating if code should be hidden
     */
    readonly hideCode: _angular_core.Signal<boolean>;
    /**
     * Handles error by showing info and redirecting to home
     * @param error - Error to display
     */
    bounce(error: any): Promise<void>;
    /**
     * Handles form based on page type
     */
    handleForm(): void;
    /**
     * Placeholder for edit form handling
     */
    ifEdit: () => void;
    /**
     * Placeholder for create form handling
     */
    ifCreate: () => void;
    /**
     * Placeholder for show form handling
     */
    ifShow: () => void;
    /**
     * Placeholder for clone form handling
     */
    ifClone: () => void;
    /**
     * Executes function if not in create mode
     * @param func - Function to execute
     */
    ifParams: (func: () => any) => void;
    /**
     * Handles form submission completion
     * @param config - Configuration object for submission completion
     * @param config.notificationMessage - Optional message to display
     * @param config.param - Optional parameters for navigation
     * @param config.route - Optional route for navigation
     */
    onSubmitComplete(config: {
        notificationMessage?: string;
        param?: IObjectLiteral;
        route?: string;
    }): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageTemplateComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageTemplateComponent<any>, "ng-component", never, { "_isModal": { "alias": "isModal"; "required": false; }; "modelData": { "alias": "modelData"; "required": false; }; }, { "modalSubmitted": "modalSubmitted"; }, never, never, true, never>;
}
/**
 * Interface for page state
 */
interface IPageState {
    /**
     * Whether page is in clone mode
     */
    isClone?: boolean;
    /**
     * Whether page is in create mode
     */
    isCreate?: boolean;
    /**
     * Whether page is in edit mode
     */
    isEdit?: boolean;
    /**
     * Whether page is in show mode
     */
    isShow?: boolean;
    /**
     * Whether page is in modal mode
     */
    isModal?: boolean;
}

/**
 * Service for managing page template types and states
 * @remarks
 * This service provides methods to determine the current page type and state
 * based on route data or explicit page type parameters.
 */
declare class PageTemplateService {
    /**
     * Current page type
     */
    pageType: EPageType;
    constructor();
    /**
     * Checks if the current page is a clone page
     * @param activatedRoute - The current activated route
     * @param pageType - Optional explicit page type
     * @returns true if the page is a clone page
     */
    isClone: (activatedRoute: ActivatedRoute, pageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a create page
     * @param activatedRoute - The current activated route
     * @param pageType - Optional explicit page type
     * @returns true if the page is a create page
     */
    isCreate: (activatedRoute: ActivatedRoute, pageType?: EPageType) => boolean;
    /**
     * Checks if the current page is an edit page
     * @param activatedRoute - The current activated route
     * @param pageType - Optional explicit page type
     * @returns true if the page is an edit page
     */
    isEdit: (activatedRoute: ActivatedRoute, pageType?: EPageType) => boolean;
    /**
     * Checks if the current page is an index page
     * @param activatedRoute - The current activated route
     * @param pageType - Optional explicit page type
     * @returns true if the page is an index page
     */
    isIndex: (activatedRoute: ActivatedRoute, pageType?: EPageType) => boolean;
    /**
     * Checks if the current page is a show/view page
     * @param activatedRoute - The current activated route
     * @param pageType - Optional explicit page type
     * @returns true if the page is a show page
     */
    isShow: (activatedRoute: ActivatedRoute, pageType?: EPageType) => boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageTemplateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageTemplateService>;
}

/**
 * Component for displaying a large progress bar with labels
 * @remarks
 * This component provides a visual representation of progress with optional start and end labels,
 * and customizable border styling.
 *
 * @example
 * ```html
 * <progress-bar-large
 *   [value]="50"
 *   startLabel="Start"
 *   endLabel="End"
 *   borderClass="custom-border">
 * </progress-bar-large>
 * ```
 */
declare class ProgressBarLargeComponent {
    /**
     * Progress value in percentage (0-100)
     * @example 50 represents 50%
     */
    value: number;
    /**
     * Label to display at the start of the progress bar
     */
    startLabel: string;
    /**
     * Label to display at the end of the progress bar
     */
    endLabel: string;
    /**
     * CSS class for customizing the border style
     */
    borderClass: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressBarLargeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBarLargeComponent, "progress-bar-large", never, { "value": { "alias": "value"; "required": false; }; "startLabel": { "alias": "startLabel"; "required": false; }; "endLabel": { "alias": "endLabel"; "required": false; }; "borderClass": { "alias": "borderClass"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for displaying a search input with optional label
 * @remarks
 * This component provides a search input field with a label and emits events when the query changes.
 * It can be used in various contexts where search functionality is needed.
 *
 * @example
 * ```html
 * <search-box
 *   [label]="'Search Users'"
 *   (queryChanged)="onSearch($event)">
 * </search-box>
 * ```
 */
declare class SearchBoxComponent {
    /**
     * Label text to display above the search input
     * @default 'Search'
     */
    label: string;
    /**
     * Current search query value
     */
    query: string;
    /**
     * Event emitted when the search query changes
     * @event
     */
    queryChanged: EventEmitter<string>;
    /**
     * Whether the search box is currently opened
     */
    opened: boolean;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchBoxComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchBoxComponent, "search-box", never, { "label": { "alias": "label"; "required": false; }; "query": { "alias": "query"; "required": false; }; }, { "queryChanged": "queryChanged"; }, never, never, true, never>;
}

/**
 * Component for exporting table data to CSV format
 * @remarks
 * This component provides functionality to export table data to CSV format.
 * It supports both direct data export and fetching data through a search function.
 *
 * @example
 * ```html
 * <app-export-table
 *   [data]="tableData"
 *   [displayedColumns]="columns"
 *   [searchFunc]="searchFunction"
 *   label="Export Data">
 * </app-export-table>
 * ```
 */
declare class ExportTableComponent implements OnInit {
    /**
     * The data to be exported
     * @remarks
     * Array of objects containing the table data
     */
    readonly data: _angular_core.InputSignal<any[]>;
    /**
     * The columns to be included in the export
     * @remarks
     * Array of TableCol objects defining the columns to export
     */
    readonly displayedColumns: _angular_core.InputSignal<TableCol<any, {
        value: string;
        label: string;
    }>[]>;
    /**
     * Function to fetch data for export
     * @remarks
     * Optional function that returns an Observable of ITableSearchFunc
     * Used when data needs to be fetched before export
     */
    readonly searchFunc: _angular_core.InputSignal<(data: any) => Observable<ITableSearchFunc<any>>>;
    /**
     * The search query parameters
     * @remarks
     * Object containing search parameters for data fetching
     */
    searchQuery: {
        [x: string]: string | number | boolean;
    };
    /**
     * Setter for search query
     * @remarks
     * Clones and processes the search query, removing pagination parameters
     */
    set _searchQuery(v: {
        [x: string]: string | number | boolean;
    });
    /**
     * The label for the export button
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * Whether the export button is disabled
     */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /**
     * Whether to process the export later instead of downloading immediately
     * @remarks
     * If true, the export will be processed asynchronously and the user will be notified
     * to check the reports page when done. If false, the export will download immediately.
     */
    readonly getLater: _angular_core.InputSignal<boolean>;
    /**
     * Loading state indicator
     */
    loading: boolean;
    /**
     * Injected utility service
     */
    uS: UtilityService;
    /**
     * Injected export table service for global configuration
     */
    private readonly exportTableService;
    constructor();
    ngOnInit(): void;
    /**
     * Worker function for converting array to CSV
     * @remarks
     * Optional function to override the default CSV conversion
     */
    arrayToCSVWorker: (array: any[], filename: string, columns?: string[], showHeader?: boolean) => Promise<void>;
    /**
     * Downloads the data as a CSV file
     * @param data - Optional data to export (defaults to this.data)
     * @param label - Optional label for the file (defaults to this.label)
     * @remarks
     * If searchFunc is provided, it will fetch all data before exporting.
     * If getLater is true, the export will be processed asynchronously and the user will be notified.
     * The getLater value is determined by component input first, then global service setting.
     */
    downloadCSV(data?: any[], label?: string): Promise<void>;
    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; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "getLater": { "alias": "getLater"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Pipe for formatting column values in a table
 * @remarks
 * This pipe handles the formatting of cell values based on the column configuration
 */
declare class GetColFormattedPipe implements PipeTransform {
    /**
     * Transforms a row value based on the column configuration
     * @param row - The row data
     * @param col - The column configuration
     * @returns Promise of the formatted value
     */
    transform(row: any, col: TableCol): Promise<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetColFormattedPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetColFormattedPipe, "getColFormatted", true>;
}
/**
 * Pipe for getting raw field names from column configurations
 * @remarks
 * This pipe extracts field names from column configurations, optionally including selection and options columns
 */
declare class GetRawFieldsPipe implements PipeTransform {
    /**
     * Transforms column configurations into an array of field names
     * @param arr - Array of column configurations
     * @param showOptions - Whether to include the options column
     * @param useSelection - Whether to include the selection column
     * @param placeSelectionAtRight - Whether to place selection at the end
     * @returns Array of field names
     */
    transform(arr: TableCol[], showOptions?: boolean, useSelection?: boolean, placeSelectionAtRight?: boolean): string[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetRawFieldsPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetRawFieldsPipe, "getRawFields", true>;
}
/**
 * Pipe for getting header text from column configurations
 * @remarks
 * This pipe extracts header text from column configurations
 */
declare class GetHeadersPipe implements PipeTransform {
    /**
     * Transforms column configurations into an array of header text
     * @param arr - Array of column configurations
     * @returns Array of header text
     */
    transform(arr: TableCol[]): string[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetHeadersPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetHeadersPipe, "getHeaders", true>;
}
/**
 * Pipe for converting table data to string format
 * @remarks
 * This pipe converts table data into a formatted string representation
 */
declare class TableToStringPipe implements PipeTransform {
    cfS: GetColFormattedPipe;
    /**
     * Transforms table data into a formatted string
     * @param arr - Array of column configurations
     * @param obj - The row data
     * @returns Promise of the formatted string
     */
    transform(arr: TableCol[], obj: any): Promise<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableToStringPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TableToStringPipe, "tableToString", true>;
}
/**
 * Module containing table-related pipes
 */
declare class TablePipesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablePipesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TablePipesModule, never, [typeof i1.CommonModule, typeof GetColFormattedPipe, typeof GetHeadersPipe, typeof GetRawFieldsPipe, typeof TableToStringPipe], [typeof GetColFormattedPipe, typeof GetHeadersPipe, typeof GetRawFieldsPipe, typeof TableToStringPipe]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TablePipesModule>;
}

/**
 * Service providing utility functions for table components
 * @remarks
 * This service provides helper functions for formatting and styling table data.
 */
declare class TablePlainService {
    constructor();
    /**
     * Formats a key to display as a colored span element
     * @param key - The key to format
     * @param codes - Array of key-value pairs mapping keys to colors
     * @returns HTML string containing a colored span element
     *
     * @example
     * ```typescript
     * formatToColours(1) // returns '<span class="green colour 1"></span>'
     * formatToColours(0) // returns '<span class="red colour 0"></span>'
     * formatToColours(2) // returns '<span class="yellow colour 2"></span>'
     * ```
     */
    formatToColours: (key: any, codes?: KeyValue$1<number, string>[]) => string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablePlainService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TablePlainService>;
}

/**
 * Component for displaying text with optional tooltip
 * @remarks
 * This component provides a simple way to display text with an optional tooltip.
 * It uses Material's tooltip functionality for enhanced user experience.
 */
declare class TextComponent {
    /**
     * The text content to display
     */
    text: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextComponent, "app-text", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Module that provides button-related components
 * @remarks
 * This module exports the following components:
 * - BtnComponent: Standard button component
 * - BtnLgComponent: Large button component
 * - BtnLinkComponent: Link-style button component
 *
 * @example
 * ```typescript
 * @NgModule({
 *   imports: [BtnModule],
 *   declarations: [MyComponent]
 * })
 * export class MyModule {}
 * ```
 */
declare class BtnModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BtnModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BtnModule, never, [typeof BtnComponent, typeof BtnLgComponent, typeof BtnLinkComponent], [typeof BtnComponent, typeof BtnLgComponent, typeof BtnLinkComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BtnModule>;
}

/**
 * Module for input-related components and functionality
 * @remarks
 * This module provides a collection of input components, pipes, and related functionality
 * for handling form inputs in Angular applications. It includes support for various input
 * types, validation, and Material Design components.
 *
 * @example
 * ```typescript
 * @NgModule({
 *   imports: [
 *     InputModule,
 *     // ... other imports
 *   ]
 * })
 * export class AppModule { }
 * ```
 */
declare class InputModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<InputModule, never, [typeof BtnModule, typeof ErrorMessagePipe, typeof ErrorMessagesPipe, typeof _angular_forms.FormsModule, typeof InputBasicComponent, typeof InputPipesModule, typeof InputTD_RFComponent, typeof i7.MatDatepickerModule, typeof i8.MatInputModule, typeof ErrorMessagePipe, typeof i9.MatNativeDateModule, typeof i10.MatSelectModule, typeof i11.MatSlideToggleModule, typeof i12.MatTooltipModule, typeof i12.MatTooltipModule, typeof OtpInputComponent, typeof _angular_forms.ReactiveFormsModule, typeof ValidationMessageComponent], [typeof BtnModule, typeof ErrorMessagePipe, typeof ErrorMessagesPipe, typeof _angular_forms.FormsModule, typeof InputBasicComponent, typeof InputPipesModule, typeof InputTD_RFComponent, typeof i7.MatDatepickerModule, typeof i8.MatInputModule, typeof i9.MatNativeDateModule, typeof i10.MatSelectModule, typeof i11.MatSlideToggleModule, typeof i12.MatTooltipModule, typeof i12.MatTooltipModule, typeof OtpInputComponent, typeof _angular_forms.ReactiveFormsModule, typeof ValidationMessageComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<InputModule>;
}

/**
 * Interface for defining upload schema configuration
 * @template TRow - The type of the row data
 * @example
 * ```ts
 * const schema: IUploadSchema = {
 *   field: 'name',
 *   label: 'Full Name',
 *   isRequired: true,
 *   removeSpecialCharacters: true
 * };
 * ```
 */
interface IUploadSchema<TRow = any> extends IFormSchema<{
    [k in keyof TRow]: FormControl<TRow[k]>;
}> {
    /**
     * Specify whether to remove \n\t from the input's value
     * @default false
     */
    removeSpecialCharacters?: boolean;
    /**
     * Specify whether to remove commas from the input's value
     * @default false
     */
    removeCommas?: boolean;
    /**
     * The date format of the input value
     */
    inputDateFormat?: EDateFormat;
    /**
     * The date format for the output value
     */
    outputDateFormat?: EDateFormat;
    /**
     * Specify whether to add zeros as a prefix
     * @default false
     */
    addPrecedingZeros?: boolean;
    /**
     * The expected length of the value, only to be used when addPrecedingZeros is set to true
     */
    expectedLength?: number;
    /**
     * Specify whether the field is mandatory
     * @default false
     */
    isRequired?: boolean;
    /**
     * Checks if a field is required based on the presence or absence of data in a set of fields
     * @example
     * ```ts
     * isRequiredIfFields: {
     *   fields: ['firstName', 'lastName'],
     *   shouldHaveValues: true,
     *   condition: 'or'
     * }
     * ```
     */
    isRequiredIfFields?: {
        fields: string[];
        /**
         * @default true
         */
        shouldHaveValues: boolean;
        /**
         * @default 'and'
         */
        condition: 'or' | 'and';
    };
    /**
     * Frontend generated ID for identifying each row of data
     */
    __ID?: any;
    /**
     * Don't show field in the upload template
     * @default false
     */
    disabled?: boolean;
    /**
     * Hide field from the UI but include in the upload template
     * @default false
     */
    hidden?: boolean;
    /**
     * Ignore field from the operations of the component
     * @default false
     */
    ignore?: boolean;
    /**
     * Value to use in the generated template file
     */
    templateValue?: any;
}
/**
 * Interface for validation response
 * @template T - The type of the data
 */
interface IValidationResp<T = any> {
    /**
     * The ID of the row being validated
     */
    rowID: string;
    /**
     * The index of the row in the data array
     */
    rowIndex?: number;
    /**
     * Array of error messages
     */
    errors?: string[];
    /**
     * Array of error controls with their labels
     */
    errorCtrls?: {
        ctrl: AbstractControl;
        label: string;
    }[];
    /**
     * The validated data
     */
    data?: T;
}
interface IValidationResp2<T = any> {
    /**
     * The field name of the rowid coming from the server
     */
    rowIDField: keyof T;
    /**
     * Specify whether to flatten each item in the response array, default is false
     */
    flattenObj?: boolean;
    /**
     * The validation array response from the backend
     */
    data?: T[];
}
/**
 * Interface for upload submission response
 */
interface IUploadSubmissionResp {
    /**
     * The name of the uploaded file
     */
    fileName?: string;
    /**
     * The path where the file is stored
     */
    filePath?: string;
    /**
     * Total number of records processed
     */
    totalProcessed?: number;
    /**
     * Total number of successful records
     */
    totalSuccess?: number;
    /**
     * Total number of failed records
     */
    totalFail?: number;
    /**
     * Whether the data is large
     */
    largeData?: boolean;
    /**
     * Percentage completion of the upload
     */
    percentageCompletion?: number;
    /**
     * Report file information
     */
    report?: {
        fileName: string;
        filePath: string;
    };
    /**
     * Array of report data
     */
    reportArray?: any[];
}
/**
 * Enum for date format options
 */
declare enum EDateFormat {
    /**
     * Format: DD-MMM-YYYY
     */
    ddmmmyyyyDashes = "DD-MMM-YYYY",
    /**
     * Format: DD/MM/YYYY
     */
    ddmmyyyySlashes = "DD/MM/YYYY",
    /**
     * Format: MM/DD/YYYY
     */
    mmddyyyySlashes = "MM/DD/YYYY",
    /**
     * Format: YYYY/MM/DD
     */
    yyyymmddSlashes = "YYYY/MM/DD",
    /**
     * Format: YYYY-MM-DD
     */
    yyyymmddDashes = "YYYY-MM-DD",
    /**
     * Format: YYYY-MM-DD HH-MM
     */
    yyyymmddDashesHHMM = "YYYY-MM-DD HH-MM"
}
/**
 * Returns an array of date format options with value and label
 * @returns Array of date format options
 * @example
 * ```ts
 * const formats = DateFormats();
 * // Returns [{ value: 'DD-MMM-YYYY', label: 'DD-MMM-YYYY' }, ...]
 * ```
 */
declare function DateFormats(): IValueLabel[];
/**
 * Interface for format configuration
 */
interface IFormatConfig {
    /**
     * Structure to remap each row in the upload data with
     */
    structure?: {
        [x: string]: any;
    };
    /**
     * Values to add to each row before upload
     */
    defaultData?: {
        [x: string]: any;
    };
    /**
     * The field name of the rowid being used by the server
     */
    rowIDField?: string;
}
interface IUploadProgress {
    /**
     * Progress text description
     */
    text?: string;
    /**
     * Start time of the operation
     */
    startTime?: number;
    /**
     * End time of the operation
     */
    endTime?: number;
    /**
     * Time taken for the operation
     */
    time?: number;
}
interface IUploadProgressObj {
    /**
     * Progress information for mandatory checks
     */
    MandatoryChecks?: IUploadProgress;
    /**
     * Progress information for validation checks
     */
    ValidationChecks?: IUploadProgress;
    /**
     * Progress information for upload
     */
    Upload?: IUploadProgress;
    /**
     * Total progress information
     */
    Total?: IUploadProgress;
    /**
     * Error information if any
     */
    error?: IUploadProgress;
}
/**
 * Interface for upload configuration
 */
interface IUploadConfig {
    /**
     * Code identifier for the upload
     */
    uploadCode: string;
    /**
     * Configuration object
     */
    config: {};
}

/**
 * Service that provides functionality for batch upload operations
 * @example
 * ```ts
 * constructor(private batchS: BatchUploadsService) {}
 *
 * uploadData(data: any[]) {
 *   const options = this.batchS.extras(data.length);
 *   // Use options for HTTP request
 * }
 * ```
 */
declare class BatchUploadsService {
    /**
     * Determines if extra options are needed based on data length
     * @param dataLength - The length of the data to be uploaded
     * @returns HTTP options with skipLogger header if data length > 10, null otherwise
     * @example
     * ```ts
     * const options = service.extras(15);
     * // Returns { options: { headers: new HttpHeaders().set('skipLogger', 'true') } }
     * ```
     */
    extras(dataLength: number): {
        options: {
            headers: HttpHeaders;
        };
    };
    constructor();
    /**
     * Formats a date string
     * @param date - The date string to format
     * @returns Formatted date string
     */
    formatDate: (date: string) => string;
    /**
     * Converts a flat object into a layered object structure
     * @template TRow - The type of the row object
     * @param flatObj - The flat object to convert
     * @param layeredObj - The target layered object
     * @param layeredObjStructure - Optional structure template for the layered object
     * @example
     * ```ts
     * const flat = { 'user.name': 'John', 'user.age': 30 };
     * const layered = {};
     * service.layerObj(flat, layered);
     * // layered becomes { user: { name: 'John', age: 30 } }
     * ```
     */
    layerObj: <TRow extends {
        [x: string]: any;
    } = any>(flatObj: {
        [x: string]: string | number | boolean;
    }, layeredObj: {
        [x: string]: any;
    }, layeredObjStructure?: TRow) => void;
    /**
     * Flattens a nested object into a single-level object
     * @param ob - The object to flatten
     * @returns Flattened object or null if input is null/empty
     * @example
     * ```ts
     * const nested = { user: { name: 'John', age: 30 } };
     * const flat = service.flattenObj(nested);
     * // Returns { 'user.name': 'John', 'user.age': 30 }
     * ```
     */
    flattenObj: (ob: any) => {};
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BatchUploadsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BatchUploadsService>;
}

/**
 * Service that provides functionality for batch upload input operations
 * @example
 * ```ts
 * constructor(private batchInputS: BatchUploadInputService) {
 *   this.batchInputS.createTemplate(schemas);
 * }
 * ```
 */
declare class BatchUploadInputService {
    /**
     * Default date format for input fields
     * @default EDateFormat.yyyymmddDashes
     */
    defaultInputDateFormat: EDateFormat;
    /**
     * Signal containing the component configuration
     */
    protected readonly _config: _angular_core.WritableSignal<IBatchUploadComponentConfig>;
    /**
     * Computed property that returns the current configuration
     */
    readonly config: _angular_core.Signal<IBatchUploadComponentConfig>;
    /**
     * Updates the component configuration
     * @param val - Partial configuration to update
     * @example
     * ```ts
     * service.updateConfig({
     *   formatForSubmissionWorker: () => new URL('./custom-worker', import.meta.url)
     * });
     * ```
     */
    updateConfig(val: Partial<IBatchUploadComponentConfig>): void;
    constructor();
    /**
     * Creates the template data for downloading the CSV upload template
     * @param schema - Array of upload schemas
     * @example
     * ```ts
     * const schemas: IUploadSchema[] = [...];
     * service.createTemplate(schemas);
     * ```
     */
    createTemplate(schema: IUploadSchema[]): void;
    /**
     * Downloads a report file
     * @param params - Parameters for downloading the report
     * @param params.fileName - Name of the file to download
     * @param params.filePath - Path of the file to download
     * @throws Error indicating the function is not implemented
     */
    downloadReport: (params: {
        fileName?: string;
        filePath?: string;
    }) => Promise<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BatchUploadInputService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BatchUploadInputService>;
}
/**
 * Interface for batch upload component configuration
 */
interface IBatchUploadComponentConfig {
    /**
     * Function that returns the URL for the format-for-submission worker
     */
    formatForSubmissionWorker: () => string | URL;
    /**
     * Function that returns the URL for the upload-csv worker
     */
    uploadCsvWorker: () => string | URL;
    /**
     * Function that returns the URL for the check-mandatory-fields worker
     */
    checkMandatoryFieldsWorker: () => string | URL;
    /**
     * Function that returns the URL for the check-validation-response worker
     */
    checkValidationResponseWorker: () => string | URL;
}

/**
 * A component for handling batch file uploads with validation and processing capabilities.
 * This component provides a comprehensive solution for uploading, validating, and processing data in batches.
 * It supports CSV file uploads, real-time validation, and progress tracking.
 *
 * @template T - The type of data being uploaded
 * @template TValidationResp - The type of validation response
 *
 * @example
 * ```typescript
 * // Basic usage
 * <batch-upload-input
 *   [label]="'User Data Upload'"
 *   [schemas]="userSchemas"
 *   [submitFunc]="submitUserData"
 *   [validationFunc]="validateUserData"
 * ></batch-upload-input>
 * ```
 */
declare class BatchUploadInputComponent<T = any, TValidationResp = any> implements OnInit {
    uS: UtilityService;
    batchInputS: BatchUploadInputService;
    batchS: BatchUploadsService;
    private cdr;
    private dP;
    /**
     * Whether to hide the download template button
     */
    readonly hideDownloadTemplate: _angular_core.InputSignal<boolean>;
    /**
     * Function to patch/transform data before processing
     */
    dataPatcher?: (val: any) => any;
    /**
     * Whether to hide the submit button
     */
    readonly hideSubmit: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show upload progress
     */
    readonly showProgress: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show validation errors inline
     */
    readonly inlineErrors: _angular_core.WritableSignal<boolean>;
    /**
     * Whether to format input/output data
     */
    ioFormatted: boolean;
    /**
     * Field to use as key in schema mapping
     */
    keyField: 'field' | 'label';
    /**
     * Label for the upload component
     */
    label?: string;
    /**
     * Available page size options for pagination
     */
    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
    /**
     * Current page size for pagination
     */
    readonly pageSize: _angular_core.InputSignal<number>;
    /**
     * Whether to enable debug mode
     */
    readonly debug: _angular_core.InputSignal<boolean>;
    /**
     * Whether to perform real-time validation
     */
    readonly realTimeValidation: _angular_core.InputSignal<boolean>;
    /**
     * Whether to ignore async validation
     */
    ignoreAsyncValidation: boolean;
    /**
     * Whether to show CSV preview
     */
    showCSV: boolean;
    /**
     * Additional guidelines to display
     */
    readonly additionalGuideline: _angular_core.InputSignal<string[]>;
    /**
     * Whether to show download report button
     */
    showDownloadReportBtn: boolean;
    /**
     * Whether to allow upload without staging
     */
    readonly allowNoStaging: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show dialog after submission
     */
    showAfterSubmissionDialog: boolean;
    /**
     * Event emitted after successful submission
     */
    submitted: EventEmitter<any>;
    /**
     * Event emitted when feedback popup is closed
     */
    closedFeedbackPopup: EventEmitter<any>;
    /**
     * Event emitted after validation
     */
    validated: EventEmitter<{
        success: boolean;
        extra: {
            component: BatchUploadInputComponent;
        };
    }>;
    /**
     * Function to format data before upload processing
     */
    dataFormatterFunction?: (arrValues: any[]) => Promise<any[]>;
    /**
     * Function to handle data submission
     */
    readonly submitFunc: _angular_core.InputSignal<IBatchSubmissionFunction<any>>;
    /**
     * Function to validate uploaded data
     */
    readonly validationFunc: _angular_core.InputSignal<IBatchValidatorFunction<TValidationResp>>;
    /**
     * Configuration for upload data formatting
     */
    uploadFormatter?: IFormatConfig;
    /**
     * Configuration for validation data formatting
     */
    validationFormatter?: IFormatConfig;
    /**
     * Event emitted when data changes
     */
    change: EventEmitter<any[]>;
    /**
     * Event emitted when data is saved
     */
    save: EventEmitter<{
        rows: T[];
    }>;
    /**
     * Event emitted when data is loaded into the UI
     */
    loadedData: EventEmitter<any[]>;
    /**
     * Default date format for input fields
     */
    defaultInputDateFormat: EDateFormat;
    /**
     * Whether to use UI preview
     */
    usePreview: boolean;
    /**
     * Whether to show save button
     */
    showSaveButton: boolean;
    /**
     * Uploaded data
     */
    uploadData?: T[];
    /**
     * Form array for managing upload data
     */
    readonly form: FormArray<FormGroup<IStrictFormGroup<T & {
        __rowID: string;
    }>>>;
    /**
     * Current upload progress percentage
     */
    uploadProgress: number;
    /**
     * Time left for upload completion
     */
    readonly uploadTimeLeft: _angular_core.WritableSignal<number>;
    /**
     * Computed string representation of time left
     */
    readonly computedUploadTimeLeft: _angular_core.Signal<string>;
    /**
     * Upload progress text messages
     */
    readonly uploadProgressTexts: _angular_core.WritableSignal<{
        text?: string;
        time?: number;
        currentTime?: number;
    }[]>;
    /**
     * Upload progress object
     */
    readonly uploadProgressObj: _angular_core.WritableSignal<IUploadProgressObj>;
    /**
     * Computed upload progress array
     */
    readonly computedUploadProgressObj: _angular_core.Signal<IUploadProgress[]>;
    /**
     * Schema for progress table
     */
    progressTableSchema: _angular_core.WritableSignal<TableCol<IUploadProgress, {
        value: string;
        label: string;
    }>[]>;
    /**
     * Total time taken for upload
     */
    totalUploadTime?: number;
    /**
     * Loading state
     */
    readonly loading: _angular_core.WritableSignal<boolean>;
    /**
     * Whether submit button was clicked
     */
    readonly clickedOnSubmit: _angular_core.WritableSignal<boolean>;
    /**
     * Whether async validation was performed
     */
    readonly hasPerformedAsyncValidation: _angular_core.WritableSignal<boolean>;
    /**
     * Upload schemas
     */
    readonly schemas: _angular_core.WritableSignal<IUploadSchema<T>[]>;
    /**
     * Whether validators have been added
     */
    private hasAddedValidators?;
    /**
     * Whether error list is loading
     */
    readonly loadingErrorList: _angular_core.WritableSignal<boolean>;
    /**
     * Validation errors
     */
    readonly errors: _angular_core.WritableSignal<IValidationResp<any>[]>;
    /**
     * Columns to display in table
     */
    readonly displayedColumns: _angular_core.WritableSignal<string[]>;
    /**
     * Countdown timer subscription
     */
    countdownTimer: Subscription;
    /**
     * Template data for download
     */
    templateData: T[];
    /**
     * Number of rows in upload
     */
    set _numOfRows(v: number | undefined);
    /**
     * Upload schemas setter
     */
    set _schemas(value: IUploadSchema<T>[]);
    /**
     * Computed schema map
     */
    readonly schemaMap: _angular_core.Signal<{
        [x: string]: IUploadSchema<any>;
    }>;
    /**
     * Error list modal reference
     */
    errorListTag?: ModalComponent;
    /**
     * Form group for data processing
     */
    dpForm: FormGroup<{
        numOfRows: FormControl<number>;
        id: FormControl<number>;
        startingRow: FormControl<number>;
        config: FormArray<FormGroup<{
            id: FormControl<number>;
            uploadConfigId: FormControl<number>;
            field: FormControl<string>;
            label: FormControl<string>;
            addPrecedingZeros: FormControl<boolean>;
            expectedLength: FormControl<number>;
            type: FormControl<InputType>;
            inputDateFormat: FormControl<EDateFormat>;
            removeCommas: FormControl<boolean>;
            removeSpecialCharacters: FormControl<boolean>;
        }>>;
    }>;
    /**
     * Computed form value
     */
    readonly dpFormValue: _angular_core.Signal<{
        numOfRows: number;
        id: number;
        startingRow: number;
        config: {
            id: number;
            uploadConfigId: number;
            field: string;
            label: string;
            addPrecedingZeros: boolean;
            expectedLength: number;
            type: InputType;
            inputDateFormat: EDateFormat;
            removeCommas: boolean;
            removeSpecialCharacters: boolean;
        }[];
    }>;
    /**
     * Stepper reference
     */
    stepperRef?: MatStepper;
    /**
     * Preview table reference
     */
    pTableRef?: MatTable<any>;
    /**
     * Data source for preview table
     */
    dataSource?: MatTableDataSource<any>;
    /**
     * Paginator reference
     */
    paginator?: MatPaginator;
    /**
     * Event emitted when file is selected
     */
    getFile: EventEmitter<File>;
    /**
     * Maximum file size in bytes
     */
    fileMaximumSize: number;
    /**
     * Available date formats
     */
    readonly dateFormats: herlhay_helpers.IValueLabel<string>[];
    /**
     * Initializes the component
     */
    ngOnInit(): void;
    /**
     * Cleans up resources when component is destroyed
     */
    ngOnDestroy(): void;
    /**
     * Creates displayed columns for staging area
     *
     * @param schemas - Upload schemas
     */
    createDisplayedColumns(schemas?: IUploadSchema<T>[]): void;
    /**
     * Validates schema setup
     *
     * @param schema - Upload fields
     * @throws Error if schema is invalid
     */
    checkSchema(schema: IUploadSchema[]): void;
    /**
     * Creates form array for schema configuration
     *
     * @param schemas - Schema list
     */
    createSchemaForm(schemas: IUploadSchema[]): void;
    /**
     * Gets schema form structure
     */
    get schemaFormStructure(): FormGroup<{
        id: FormControl<number>;
        uploadConfigId: FormControl<number>;
        field: FormControl<string>;
        label: FormControl<string>;
        addPrecedingZeros: FormControl<boolean>;
        expectedLength: FormControl<number>;
        type: FormControl<InputType>;
        inputDateFormat: FormControl<EDateFormat>;
        removeCommas: FormControl<boolean>;
        removeSpecialCharacters: FormControl<boolean>;
    }>;
    /**
     * Computed dates prompt
     */
    readonly computedDatesPrompt: _angular_core.Signal<ITextCase2<any>[]>;
    /**
     * Validates if validation button has been clicked
     *
     * @param form - Form array
     * @returns Validation error if validation hasn't been performed
     */
    checkValidatorButton(form: AbstractControl): CustomValidationError | null;
    /**
     * Shows number of invalid rows
     *
     * @param form - Form array
     * @returns Validation error with number of invalid rows
     */
    showNumberOfInvalidRows(form: FormArray): CustomValidationError | null;
    /**
     * Downloads report
     *
     * @param params - Upload submission response
     * @returns Promise that resolves when report is downloaded
     */
    downloadReport: (params: IUploadSubmissionResp) => void | Promise<any>;
    /**
     * Enables all rows in form
     */
    enableRows(): void;
    /**
     * Tracks form items by row ID
     *
     * @param index - Item index
     * @param item - Form item
     * @returns Row ID
     */
    subFormTrackBy: (index: number, item: any) => any;
    /**
     * Tracks schema items by ID
     *
     * @param index - Item index
     * @param item - Schema item
     * @returns Schema ID
     */
    schemeTrackBy: (index: number, item: IUploadSchema) => any;
    /**
     * Toggles row edit mode
     *
     * @param index - Row index
     */
    editRow(index: number): void;
    /**
     * Removes row from form
     *
     * @param index - Row index
     */
    removeRow(index: number): void;
    /**
     * Creates row form
     *
     * @param data - Row data
     * @param _schemas - Upload schemas
     * @returns Form group for row
     */
    createRowForm: (data?: any, _schemas?: IUploadSchema<T>[]) => FormGroup<IStrictFormGroup<T & {
        __rowID: string;
    }>>;
    /**
     * Gets whether form is pending
     */
    get formIsPending(): boolean;
    /**
     * Logs form state
     */
    logForm(): void;
    /**
     * Scrolls to row
     *
     * @param rowid - Row ID
     */
    jumpTo(rowid: string): void;
    /**
     * Shows validation errors
     */
    showErrors(): void;
    /**
     * Performs mandatory validation
     */
    checkMandatoryValidation(): void;
    /**
     * Performs async validation
     */
    validateAsync(): Promise<void>;
    /**
     * Adds row to form
     *
     * @param index - Index to insert at
     * @param form - Form to add
     */
    addRow: (index?: number, form?: FormGroup<IStrictFormGroup<T & {
        __rowID: string;
    }>>) => void;
    /**
     * Clears form and upload data
     */
    clear(): void;
    /**
     * Parses uploaded file
     *
     * @param file - File to parse
     * @param loader - Loader component
     */
    parseUpload(file: File, loader: LoaderComponent): void;
    /**
     * Gets schemas for web worker
     */
    readonly workerSchemas: _angular_core.Signal<{
        label: string;
        field: string;
        type: InputType;
        addPrecedingZeros: boolean;
        expectedLength: number;
        inputDateFormat: EDateFormat;
        removeCommas: boolean;
        removeSpecialCharacters: boolean;
        isRequired: boolean;
        disabled: boolean;
        outputDateFormat: EDateFormat;
        isRequiredIfFields: {
            fields: string[];
            shouldHaveValues: boolean;
            condition: "or" | "and";
        };
        isRequiredIfMissingFields: {
            fields: string[];
            shouldHaveValues: boolean;
            condition: "or" | "and";
        };
    }[]>;
    /**
     * Downloads data as CSV
     *
     * @param rows - Data rows
     * @param label - File label
     * @param prefixColumns - Additional columns to prefix
     */
    downloadCSV(rows?: any[], label?: string, prefixColumns?: {
        label: string;
        field: string;
    }[]): void;
    /**
     * Downloads template CSV
     */
    downloadTemplate(): void;
    /**
     * Computed guidelines
     */
    guideLines: _angular_core.Signal<string[]>;
    /**
     * Validates upload data
     */
    validate(): Promise<void>;
    /**
     * Submits data without preview
     */
    backendSubmit(): Promise<void>;
    /**
     * Submits form data
     */
    submit(): Promise<void>;
    /**
     * Handles post-submission actions
     *
     * @param res - Submission response
     */
    afterSubmission(res?: IUploadSubmissionResp): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BatchUploadInputComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BatchUploadInputComponent<any, any>, "batch-upload-input", never, { "hideDownloadTemplate": { "alias": "hideDownloadTemplate"; "required": false; "isSignal": true; }; "dataPatcher": { "alias": "dataPatcher"; "required": false; }; "hideSubmit": { "alias": "hideSubmit"; "required": false; "isSignal": true; }; "showProgress": { "alias": "showProgress"; "required": false; "isSignal": true; }; "ioFormatted": { "alias": "ioFormatted"; "required": false; }; "keyField": { "alias": "keyField"; "required": false; }; "label": { "alias": "label"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "realTimeValidation": { "alias": "realTimeValidation"; "required": false; "isSignal": true; }; "ignoreAsyncValidation": { "alias": "ignoreAsyncValidation"; "required": false; }; "showCSV": { "alias": "showCSV"; "required": false; }; "additionalGuideline": { "alias": "additionalGuideline"; "required": false; "isSignal": true; }; "showDownloadReportBtn": { "alias": "showDownloadReportBtn"; "required": false; }; "allowNoStaging": { "alias": "allowNoStaging"; "required": false; "isSignal": true; }; "showAfterSubmissionDialog": { "alias": "showAfterSubmissionDialog"; "required": false; }; "dataFormatterFunction": { "alias": "dataFormatterFunction"; "required": false; }; "submitFunc": { "alias": "submitFunc"; "required": false; "isSignal": true; }; "validationFunc": { "alias": "validationFunc"; "required": false; "isSignal": true; }; "uploadFormatter": { "alias": "uploadFormatter"; "required": false; }; "validationFormatter": { "alias": "validationFormatter"; "required": false; }; "defaultInputDateFormat": { "alias": "defaultInputDateFormat"; "required": false; }; "usePreview": { "alias": "usePreview"; "required": false; }; "showSaveButton": { "alias": "showSaveButton"; "required": false; }; "templateData": { "alias": "templateData"; "required": false; }; "_numOfRows": { "alias": "numOfRows"; "required": false; }; "_schemas": { "alias": "schemas"; "required": false; }; }, { "submitted": "submitted"; "closedFeedbackPopup": "closedFeedbackPopup"; "validated": "validated"; "change": "change"; "save": "save"; "loadedData": "loadedData"; "getFile": "getFile"; }, never, never, true, never>;
}
/**
 * Function type for batch submission
 *
 * @template TRow - Type of row data
 */
type IBatchSubmissionFunction<TRow = any> = (arrValues: TRow[], extra?: {
    component: BatchUploadInputComponent;
}) => Observable<IUploadSubmissionResp | undefined>;
/**
 * Function type for batch validation
 *
 * @template T - Type of validation response
 */
type IBatchValidatorFunction<T = any> = (arrVal: any[], extra?: {
    component: BatchUploadInputComponent;
}) => Observable<IValidationResp2<T>>;

/**
 * Base component for batch upload functionality
 * @template T - The type of data being uploaded
 * @example
 * ```ts
 * @Component({
 *   template: '<batch-upload-base [schemas]="schemas"></batch-upload-base>'
 * })
 * export class MyBatchUploadComponent extends BatchUploadBaseComponent<MyDataType> {
 *   constructor(route: ActivatedRoute) {
 *     super(route);
 *   }
 * }
 */
declare class BatchUploadBaseComponent<T = any> {
    route: ActivatedRoute;
    /**
     * Signal containing the upload schemas
     */
    readonly schemas: _angular_core.WritableSignal<IUploadSchema<any>[]>;
    /**
     * Signal indicating which field to use as the key ('label' or 'field')
     * @default 'field'
     */
    readonly keyField: _angular_core.WritableSignal<"label" | "field">;
    /**
     * The structure for submission data
     */
    submissionStructure: any;
    /**
     * Signal containing the label for the upload
     * @default Value from route data or 'title'
     */
    readonly label: _angular_core.WritableSignal<string>;
    /**
     * Signal containing the number of rows to display
     * @default 2 in development, undefined in production
     */
    readonly numOfRows: _angular_core.WritableSignal<number>;
    /**
     * Signal containing the submission function
     */
    submitFuncSignal: _angular_core.WritableSignal<IBatchSubmissionFunction>;
    private _submitFunc?;
    /**
     * Gets the submission function
     */
    get submitFunc(): IBatchSubmissionFunction | undefined;
    /**
     * Sets the submission function and updates the signal
     * @param value - The new submission function
     */
    set submitFunc(value: IBatchSubmissionFunction | undefined);
    /**
     * Signal containing the validation function
     */
    validationFuncSignal: _angular_core.WritableSignal<IBatchValidatorFunction<T>>;
    private _validationFunc?;
    /**
     * Gets the validation function
     */
    get validationFunc(): IBatchValidatorFunction<T> | undefined;
    /**
     * Sets the validation function and updates the signal
     * @param value - The new validation function
     */
    set validationFunc(value: IBatchValidatorFunction<T> | undefined);
    /**
     * Signal containing the upload formatter configuration
     * @default { rowIDField: 'rowId' }
     */
    uploadFormatter: _angular_core.WritableSignal<IFormatConfig>;
    /**
     * Signal containing the validation formatter configuration
     * @default { rowIDField: 'rowId' }
     */
    validationFormatter: _angular_core.WritableSignal<IFormatConfig>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BatchUploadBaseComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BatchUploadBaseComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
}

/**
 * Namespace containing template values for batch upload operations
 * @example
 * ```ts
 * const date = BatchUpload.templateDateValue; // '01/20/2022'
 * const number = BatchUpload.templateNumberValue; // 123456
 * ```
 */
declare namespace BatchUpload {
    /**
     * Template date value for batch uploads
     * @default '01/20/2022'
     */
    const templateDateValue = "01/20/2022";
    /**
     * Template number value for batch uploads
     * @default 123456
     */
    const templateNumberValue = 123456;
    /**
     * Template checkbox value for batch uploads
     * @default false
     */
    const templateCheckboxValue = false;
}

/**
 * Component for displaying a progress bar with countdown functionality
 * @remarks
 * This component provides both horizontal and circular progress bars with countdown functionality.
 * It supports custom total time and emits events when the countdown completes.
 */
declare class MovingProgressBarComponent {
    protected interval: any;
    protected isHorizontal: boolean;
    protected isCircular: boolean;
    /**
     * Progress in percentage
     */
    protected countdown: number;
    /**
     * Actual time spent
     */
    protected timeSpent: number;
    /**
     * Actual total time
     */
    protected totalTime: number;
    /**
     * The diameter of the progress spinner (will set width and height of svg).
     */
    diameter: number;
    /**
     * In seconds
     */
    set _totalTime(v: number);
    /**
     * Show an horizontal progress bar
     */
    set _isHorizontal(v: boolean);
    /**
     * Show a circular progress bar
     */
    set _isCircular(v: boolean);
    /**
     * Emitted when the countdown is complete
     */
    completed: EventEmitter<boolean>;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MovingProgressBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MovingProgressBarComponent, "moving-progress-bar", never, { "diameter": { "alias": "diameter"; "required": false; }; "_totalTime": { "alias": "totalTime"; "required": true; }; "_isHorizontal": { "alias": "isHorizontal"; "required": false; }; "_isCircular": { "alias": "isCircular"; "required": false; }; }, { "completed": "completed"; }, never, never, true, never>;
}

/**
 * Component for displaying animated trailing dots
 * @remarks
 * This component creates an animation of dots appearing and disappearing in sequence.
 * It's commonly used to indicate loading or processing states.
 *
 * @example
 * ```html
 * <trailing-dots [speed]="500"></trailing-dots>
 * ```
 */
declare class TrailingDotsComponent {
    /**
     * Array of dot objects with visibility state
     */
    protected dots: {
        value: string;
        visible?: boolean;
    }[];
    /**
     * Animation speed in milliseconds
     * @default 500
     */
    speed: number;
    /**
     * Current dot index
     */
    protected index: number;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrailingDotsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TrailingDotsComponent, "trailing-dots", never, { "speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component for handling modal interactions
 * @remarks
 * This component provides a unified interface for managing both center and side modals,
 * handling their opening, closing, and event subscriptions.
 *
 * @example
 * ```html
 * <lib-modal-handler
 *   (modalClose)="onModalClose()">
 *   <!-- Modal content -->
 * </lib-modal-handler>
 * ```
 */
declare class ModalHandlerComponent {
    /** Reference to the side modal component */
    readonly sideModal: _angular_core.Signal<SideModalComponent>;
    /** Reference to the center modal component */
    readonly centerModal: _angular_core.Signal<ModalComponent>;
    /** Event emitted when the modal is closed */
    readonly modalClose: _angular_core.OutputEmitterRef<void>;
    /** Computed reference to the active modal */
    readonly modal: _angular_core.Signal<ModalComponent>;
    /** Function to call when the modal is opened */
    protected onOpenFunc: (formData?: any) => void;
    /** Function to call when the modal is closed */
    protected onCloseFunc: () => void;
    /** Subscription for modal open events */
    protected onOpenSub: OutputRefSubscription;
    /**
     * Opens the modal and sets up event handlers
     * @param formData - Optional data to pass to the open function
     */
    open(formData?: any): void;
    /**
     * Closes the modal and cleans up subscriptions
     */
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalHandlerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalHandlerComponent, "lib-modal-handler", never, {}, { "modalClose": "modalClose"; }, never, never, true, never>;
}

/**
 * A directive that provides responsive behavior for elements based on viewport size.
 * This directive allows applying different classes and visibility based on mobile/desktop viewports.
 *
 * @example
 * ```html
 * <div [mresponsiveness] [mobileClass]="'mobile-layout'" [desktopClass]="'desktop-layout'">
 *   Content
 * </div>
 * ```
 */
declare class ResponsivenessDirective {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** CSS class to apply when viewport is mobile */
    mobileClass: string;
    /** CSS class to apply when viewport is desktop */
    desktopClass: string;
    /** Whether to hide the element on mobile viewport */
    hideMobile: boolean;
    /** Whether to hide the element on desktop viewport */
    hideDesktop: boolean;
    /** Subscription to mobile query changes */
    sub: Subscription;
    /** Initializes responsive behavior after view initialization */
    ngAfterViewInit(): void;
    /** Cleans up subscription when directive is destroyed */
    ngOnDestroy(): void;
    /** Applies mobile-specific styles and visibility */
    handleMobile(): void;
    /** Applies desktop-specific styles and visibility */
    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>;
}
/**
 * A directive that applies CSS classes only on mobile viewport
 *
 * @example
 * ```html
 * <div [mobileClass]="'mobile-only'">Mobile Content</div>
 * ```
 */
declare class mobileClassDirective {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** CSS class to apply when viewport is mobile */
    mobileClass: string;
    /** Subscription to mobile query changes */
    sub: Subscription;
    /** Initializes mobile class behavior after view initialization */
    ngAfterViewInit(): void;
    /** Cleans up subscription when directive is destroyed */
    ngOnDestroy(): void;
    /** Applies mobile class when viewport is mobile */
    handleMobile(): void;
    /** Removes mobile class when 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>;
}
/**
 * A directive that applies CSS classes only on desktop viewport
 *
 * @example
 * ```html
 * <div [desktopClass]="'desktop-only'">Desktop Content</div>
 * ```
 */
declare class desktopClassDirective {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** CSS class to apply when viewport is desktop */
    desktopClass: string;
    /** Subscription to mobile query changes */
    sub: Subscription;
    /** Initializes desktop class behavior after view initialization */
    ngAfterViewInit(): void;
    /** Cleans up subscription when directive is destroyed */
    ngOnDestroy(): void;
    /** Removes desktop class when viewport is mobile */
    handleMobile(): void;
    /** Applies desktop class when 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>;
}
/**
 * A directive that hides elements on mobile viewport
 *
 * @example
 * ```html
 * <div hideMobile>Hidden on Mobile</div>
 * ```
 */
declare class hideMobileDirective {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** Subscription to mobile query changes */
    sub: Subscription;
    /** Initializes hide behavior after view initialization */
    ngAfterViewInit(): void;
    /** Cleans up subscription when directive is destroyed */
    ngOnDestroy(): void;
    /** Hides element when viewport is mobile */
    handleMobile(): void;
    /** Shows element when viewport is desktop */
    handleDesktop(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<hideMobileDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<hideMobileDirective, "[hideMobile]", never, {}, {}, never, never, true, never>;
}
/**
 * A directive that hides elements on desktop viewport
 *
 * @example
 * ```html
 * <div hideDesktop>Hidden on Desktop</div>
 * ```
 */
declare class hideDesktopDirective {
    elRef: ElementRef<HTMLDivElement>;
    uS: UtilityService;
    /** Subscription to mobile query changes */
    sub: Subscription;
    /** Initializes hide behavior after view initialization */
    ngAfterViewInit(): void;
    /** Cleans up subscription when directive is destroyed */
    ngOnDestroy(): void;
    /** Shows element when viewport is mobile */
    handleMobile(): void;
    /** Hides element when viewport is desktop */
    handleDesktop(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<hideDesktopDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<hideDesktopDirective, "[hideDesktop]", never, {}, {}, never, never, true, never>;
}

/**
 * A directive that enables drag and drop file upload functionality for any element.
 * This directive provides visual feedback during drag operations and emits dropped files.
 *
 * @example
 * ```html
 * <div libDragDropFileUpload (fileDropped)="onFileDropped($event)">
 *   Drop files here
 * </div>
 * ```
 */
declare class DragDropFileUploadDirective {
    /** Event emitter that fires when files are dropped on the element */
    fileDropped: EventEmitter<File[]>;
    /** Host binding for the background color of the element during drag operations */
    private background;
    /**
     * Handles the dragover event
     * @param event - The dragover event
     */
    dragOver(event: any): void;
    /**
     * Handles the dragleave event
     * @param event - The dragleave event
     */
    dragLeave(event: any): void;
    /**
     * Handles the drop event
     * @param event - The drop event
     */
    drop(event: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragDropFileUploadDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DragDropFileUploadDirective, "[libDragDropFileUpload]", never, {}, { "fileDropped": "fileDropped"; }, never, never, true, never>;
}

/**
 * Service that provides configuration for image loading optimization.
 * This service controls whether the image loader directive should use optimized images.
 *
 * @example
 * ```typescript
 * constructor(private imageLoaderService: ImageLoaderService) {
 *   this.imageLoaderService.useOptimizer = true; // Enable image optimization
 * }
 * ```
 */
declare class ImageLoaderService {
    /** Whether to use optimized versions of images when available */
    useOptimizer: boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageLoaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ImageLoaderService>;
}

/**
 * A directive that handles image loading with support for optimized images and fallbacks.
 * This directive can load images either as background images or as img elements.
 *
 * @example
 * ```html
 * <!-- As background image -->
 * <div [imageLoader]="'path/to/image.jpg'" imgType="bg"></div>
 *
 * <!-- As img element -->
 * <img [imageLoader]="'path/to/image.jpg'" imgType="img">
 * ```
 */
declare class ImageLoaderDirective {
    elRef: ElementRef<HTMLElement | HTMLImageElement>;
    service: ImageLoaderService;
    /** Path to the image */
    src: string;
    /** Reference to the HTML element */
    el: HTMLElement | HTMLImageElement;
    /**
     * Sets the image source and triggers image loading
     * @param v - Path to the image
     */
    set imageLoader(v: string);
    /**
     * Specifies whether the image should be loaded as a background image or img element
     * @default 'img'
     */
    imgType: EImgType;
    /** Initializes image loading after view initialization */
    ngAfterViewInit(): void;
    /**
     * Sets up the image loading process
     * @param src - Path to the image
     * @param imgType - Type of image loading (background or img element)
     */
    setImage(src?: string, imgType?: "img" | "bg"): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageLoaderDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ImageLoaderDirective, "[imageLoader]", never, { "imageLoader": { "alias": "imageLoader"; "required": false; }; "imgType": { "alias": "imgType"; "required": false; }; }, {}, never, never, true, never>;
}
/** Image type enum object */
declare const imgTypeEnum: {
    bg: boolean;
    img: boolean;
};
/** Type representing the supported image loading types */
type EImgType = keyof typeof imgTypeEnum;

/**
 * A directive that provides enhanced router link functionality with support for email and phone links.
 * This directive can be used to create clickable elements that navigate to routes, open email clients, or dial phone numbers.
 *
 * @example
 * ```html
 * <a [mrouterLink]="'/about'" [mqueryParams]="{id: 1}">About</a>
 * <a [mrouterLink]="'mail@example.com'" [isEmail]="true">Email Us</a>
 * <a [mrouterLink]="'+1234567890'" [isPhone]="true">Call Us</a>
 * ```
 */
declare class MrouterLinkirective {
    protected el: ElementRef<HTMLAnchorElement>;
    protected route: ActivatedRoute;
    protected router: Router;
    protected uS: UtilityService;
    /** The target route, email address, or phone number */
    mrouterLink: string;
    /**
     * Sets the router link target and updates the element's behavior
     * @param v - The target route, email address, or phone number
     */
    set _mrouterLink(v: string);
    /**
     * The activated route to use for relative navigation
     * @example
     * ```html
     * <a [mrouterLink]="'../parent'" [mrouterLinkActivatedRoute]="route">Go to Parent</a>
     * ```
     */
    mrouterLinkActivatedRoute: ActivatedRoute;
    /**
     * Query parameters to include in the navigation
     * @example
     * ```html
     * <a [mrouterLink]="'/search'" [mqueryParams]="{q: 'angular', page: 1}">Search</a>
     * ```
     */
    mqueryParams: any;
    /**
     * Whether the link is a phone number
     * When true, clicking the link will open the device's phone dialer
     * @example
     * ```html
     * <a [mrouterLink]="'+1234567890'" [isPhone]="true">Call Us</a>
     * ```
     */
    isPhone: boolean;
    /**
     * Whether the link is an email address
     * When true, clicking the link will open the device's email client
     * @example
     * ```html
     * <a [mrouterLink]="'contact@example.com'" [isEmail]="true">Email Us</a>
     * ```
     */
    isEmail: boolean;
    /** Initializes the router link after the view is initialized */
    ngAfterViewInit(): void;
    /**
     * Configures the element's behavior based on the router link type
     * Sets up appropriate href and click handlers for navigation, email, or phone links
     */
    setRouter(): void;
    /**
     * Converts query parameters object to a URL query string
     * @param q - The query parameters object
     * @returns The URL query string
     */
    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>;
}

declare class DirectivesModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DirectivesModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DirectivesModule, never, [typeof desktopClassDirective, typeof DragDropFileUploadDirective, typeof hideDesktopDirective, typeof hideMobileDirective, typeof ImageLoaderDirective, typeof mobileClassDirective, typeof MrouterLinkirective, typeof ResponsivenessDirective], [typeof desktopClassDirective, typeof DragDropFileUploadDirective, typeof hideDesktopDirective, typeof hideMobileDirective, typeof ImageLoaderDirective, typeof mobileClassDirective, typeof MrouterLinkirective, typeof ResponsivenessDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DirectivesModule>;
}

declare class SharedModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SharedModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SharedModule, never, [typeof AutocompleteComponent, typeof BtnComponent, typeof ChipListAutocompleteComponent, typeof i1.CommonModule, typeof ConfirmDialogComponent, typeof CountComponent, typeof FeedbackCardComponent, typeof FileUploadComponent, typeof FormGeneratorComponent, typeof GridOrListComponent, typeof ImportItemsComponent, typeof InfoIconComponent, typeof ListingFiltersComponent, typeof LoaderComponent, typeof MiniSearchListComponent, typeof ModalComponent, typeof ModalFormComponent, typeof ModalHeaderComponent, typeof NoListComponent, typeof NumberItemsSelectedComponent, typeof PageTemplateComponent, typeof ProgressBarLargeComponent, typeof ResponseCardComponent, typeof SearchBoxComponent, typeof SvgIconComponent, typeof TableHttpsComponent, typeof TablePlainComponent, typeof TextComponent, typeof TrailingDotsComponent, typeof MovingProgressBarComponent, typeof ModalHandlerComponent], [typeof AutocompleteComponent, typeof BtnComponent, typeof ChipListAutocompleteComponent, typeof ConfirmDialogComponent, typeof CountComponent, typeof DirectivesModule, typeof FeedbackCardComponent, typeof FileUploadComponent, typeof FormGeneratorComponent, typeof GridOrListComponent, typeof ImportItemsComponent, typeof InfoIconComponent, typeof InputModule, typeof ListingFiltersComponent, typeof LoaderComponent, typeof MiniSearchListComponent, typeof ModalHeaderComponent, typeof ModalComponent, typeof NoListComponent, typeof NumberItemsSelectedComponent, typeof PageTemplateComponent, typeof ResponseCardComponent, typeof SearchBoxComponent, typeof SvgIconComponent, typeof TableHttpsComponent, typeof TablePlainComponent, typeof TextComponent, typeof UtilityPipesModule, typeof ModalFormComponent, typeof ProgressBarLargeComponent, typeof TrailingDotsComponent, typeof MovingProgressBarComponent, typeof ModalHandlerComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SharedModule>;
}

/**
 * Namespace containing utility functions for Angular routing and string manipulation
 */
declare namespace HHFunctions {
    /**
     * Extends a route configuration with additional routes for common CRUD operations
     * @param route - The base route configuration to extend
     * @param param2 - Configuration options for extending the route
     * @param param2.indexRoute - Optional route configuration for the index page
     * @param param2.pathPrefix - Optional prefix to add to edit/view paths
     * @param param2.pathSuffix - Optional suffix to add to edit/view paths
     * @param param2.lazyModule - Optional lazy-loaded module for the index page
     * @param param2.lazyComponent - Optional lazy-loaded component for the index page
     * @param param2.component - Optional component for the index page
     * @returns An array of routes including index, add, edit, and view routes
     * @example
     * ```ts
     * Functions.extendRoute(
     *  {
     *     path: '',
     *     data: { title: 'Title' },
     *     loadChildren: () => import('./create-item/create-item.module')
     *       .then((m) => m.CreateItemModule),
     *  },
     *  null,
     *  () => import('./item-index/item-index.module')
     *     .then((m) => m.ItemIndexModule));
     * ```
     */
    function extendRoute(route: Route, index?: {
        lazyModule?: Route['loadChildren'];
        lazyComponent?: Route['loadComponent'];
        component?: Route['component'];
    }): Routes;
    function extendRoute(route: Route, config?: {
        indexRoute?: Route;
        pathPrefix?: string;
        pathSuffix?: string;
    }): Routes;
    function strConcatenator(values?: (string | number | boolean)[], joiner?: string): string;
    /**
     * Concatenates strings, numbers, or booleans with an optional joiner
     * @param field1 - First value or array of values to concatenate
     * @param field2 - Second value to concatenate (if param1 is not an array)
     * @param joiner - String to join values with (defaults to space)
     * @returns Concatenated string
     * @example
     * ```ts
     * strConcatenator(['Hello', 'World'], '-') // Returns 'Hello-World'
     * strConcatenator('Hello', 'World') // Returns 'Hello World'
     * ```
     */
    function strConcatenator(field1?: string | number | boolean, field2?: string | number | boolean, joiner?: string): string;
    /**
     * Extracts a name from an object using various possible name properties
     * @param obj - Object containing name properties
     * @returns Extracted name string or concatenated first and last name
     * @example
     * ```ts
     * nameExtractor({ name: 'John' }) // Returns 'John'
     * nameExtractor({ firstName: 'John', lastName: 'Doe' }) // Returns 'John Doe'
     * ```
     */
    function nameExtractor(obj: any): string;
    /**
     * Generates a UUID v4 string
     * @returns A UUID v4 string
     * @example
     * ```ts
     * generateUUID() // Returns something like '550e8400-e29b-41d4-a716-446655440000'
     * ```
     */
    const generateUUID: () => string;
    /**
     * Creates a redirect route configuration for user management
     * @param route - Original route to redirect from
     * @param prefix - Prefix to add to the new route path
     * @returns Array containing the redirect route and the modified route
     * @example
     * ```ts
     * redirectRouteForUM({ path: 'users' }, '/admin/')
     * // Returns [{ path: 'users', redirectTo: '/admin/users' }, { path: '/admin/users' }]
     * ```
     */
    function redirectRouteForUM(route: Route, prefix: string): Routes;
}

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

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

declare class ResetComponent implements OnInit {
    private swService;
    loading: boolean;
    ngOnInit(): void;
    clearCache(): void;
    getUpdates(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResetComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResetComponent, "app-reset", never, {}, {}, never, never, true, never>;
}

declare class PageNotFoundComponent implements OnInit {
    route: ActivatedRoute;
    uS: UtilityService;
    config: {
        status: string;
        message: string;
    };
    ngOnInit(): void;
    back(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageNotFoundComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageNotFoundComponent, "app-page-not-found", never, {}, {}, never, never, true, never>;
}

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

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

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

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

export { AddItemComponent, ApiService, AppService, ArraySplitter, AuthenticationInterceptorService, AutocompleteComponent, BatchUpload, BatchUploadBaseComponent, BatchUploadInputComponent, BatchUploadInputService, BatchUploadsService, Btn, BtnComponent, BtnLg, BtnLgComponent, BtnLinkComponent, BtnLoaderComponent, BtnModule, BtnService, CacheService, CheckForUpdateService, ChipListAutocompleteComponent, Config, ConfirmDialogComponent, ConfirmDialogService, Constant, ContentPaginatorComponent, CountComponent, CustomDatePipe, DEFAULT_TIMEOUT, DateAgoPipe, DateFormats, Day, DirectivesModule, DragDropFileUploadDirective, EDateFormat, ELanguage, EMenuLocation, EMenuType, EPageBtnID, EPageType, EPeriod, EValidationType, EncryptorService, Environment, ErrorMessagePipe, ErrorMessagesPipe, ExportTableComponent, ExtraPagesModule, ExtraPagesRoutingModule, ExtraPagesStandaloneRoutes, FKVP, FeedbackCardComponent, FileUploadComponent, FilterArrayByStringPipe, FilterArrayPipe, FilterFormArrayPipe, FilterOptions, FindItemComponent, FindItemService, FormGeneratorComponent, FormGeneratorService, FormGeneratorTdComponent, FormatCountPipe, Forms, FunctionCaller, FunctionCaller1, FunctionCaller2, FunctionCaller3, GenderPipe, GetColFormattedPipe, GetHeadersPipe, GetRawFieldsPipe, GetValueLabel, GlobalErrorHandlerService, GridOrListComponent, HHFunctions, HHenvironment, HandleUnrecoverableStateService, HttpListCaller, HttpListCaller1, HttpListCaller2, IRSocket, IconComponent, IconService, IdlerComponent, IdlerService, ImageLoaderDirective, ImportItemsComponent, InfoDialogComponent, InfoDialogService, InfoIconComponent, InputBasicComponent, InputClassPipe, InputModule, InputPipesModule, InputService, InputTD_RFComponent, IsClonePage, IsShowPage, KVP, Lbl, ListingFiltersComponent, Loader, LoaderComponent, LoaderCoreComponent, LoaderService, LocalCacheService, LogUpdateService, MenuItem, MenuItemDivider, MiniSearchListComponent, MixPanelService, ModalBodyDirective, ModalComponent, ModalFooterDirective, ModalFormComponent, ModalHandlerComponent, ModalHeaderComponent, ModalModule, ModalService, MovingProgressBarComponent, MrouterLinkirective, MultiTenantInterceptorService, NoListComponent, NumberItemsSelectedComponent, NumberToWordsClass, NumberToWordsPipe, NumberToWordsService, OptionLabeller, OptionerPipe, OptionsFormatter, OtpInputComponent, PageLoaderService, PageNotFoundComponent, PageNotFoundModule, PageNotFoundRoutingModule, PageService, PageTemplateComponent, PageTemplateService, PatchSdkService, ProgressBarLargeComponent, ProgressLoader, ProgressLoaders, PromptUpdateService, prototypes_d as Prototypes, ReplaceAllPipe, RequestLoggerInterceptorService, RequestTimeoutInterceptorService, ResetComponent, ResetModule, ResetRoutingModule, ResponseCardComponent, ResponsivenessDirective, RoundPipe, RowActionsComponent, BaseService as SDKBaseService, SearchBoxComponent, SecondsToTimePipe, SelectionData, ServiceWorkerService, SharedModule, SideModalComponent, SortPipe, StorageService, StrConcatenatorPipe, SvgIconComponent, SvgIconService, TableCol, TableHttpsComponent, TablePipesModule, TablePlainComponent, TablePlainService, TableToStringPipe, TawkIoService, TextCase2Component, TextCase2ForObject, TextComponent, ToAnyArrayPipe, ToAnyPipe, TrailingDotsComponent, TrimPipe, TrimTextPipe, UtilityPipesModule, UtilityService, ValidationMessageComponent, ValidationMsg, Validator, ValueFormatterPipe, ValueOrXPipe, WebsocketService, XOrYPipe, configForms, configPatterns, configValidationMessages, desktopClassDirective, hideDesktopDirective, hideMobileDirective, mobileClassDirective, modalGeneralConfig, on401Response };
export type { BtnGroup, BtnType, CellType, CustomValidationError, EIcon, IAPIExtra, IBatchSubmissionFunction, IBatchValidatorFunction, IBtn, ICode, ICodeDescription, ICodeTitle, IConfigImages, IFormOptions, IFormSchema, IFormSchema2, IFormatConfig, IInfoDialogBtn, IKVP, ILbl, IListValue, ILoaderConfig, IMenuItem, IMenuItemBase, IMenuItemRaw, IMenuItemRawBase, IMktDescription, IObjectLiteral, IOption, IPageState, IResponse, IRowOption, IRowOptionMap, ISearchFormSchema, ISearchQuery, ISearchResponse, ISearchResponse2, ISortOptionsListItem, IState, IStrictFormGroup, ITab, ITableBtn, ITableCol, ITableName, ITableSearchFunc, ITextCase2, IUploadConfig, IUploadProgress, IUploadProgressObj, IUploadSchema, IUploadSubmissionResp, IValidationMessage, IValidationResp, IValidationResp2, IValueLabel, IconNames, IconType, ImageType, InputType, KeyOfType, KeyValue, OptionLabelType, PartialNull, SVGIconType, SortType, TListFunction };