import * as i0 from '@angular/core';
import { OnChanges, ElementRef, Renderer2, PipeTransform, Provider, InjectionToken, Signal, Type, OnInit, InputSignalWithTransform, InputSignal, AfterViewInit, OnDestroy, OutputEmitterRef, TemplateRef, WritableSignal, ModelSignal, AfterViewChecked, AfterContentChecked } from '@angular/core';
import { HttpErrorResponse } from '@angular/common/http';
import { Observable, Subject } from 'rxjs';
import { FormControl, ValidatorFn, AbstractControl, ValidationErrors, ControlValueAccessor, Validator, FormGroup } from '@angular/forms';
import { ThemePalette } from '@angular/material/core';
import { MatDialogConfig } from '@angular/material/dialog';
import { MatDrawer } from '@angular/material/sidenav';
import { ComponentType as ComponentType$1 } from '@angular/cdk/portal';
import { OverlayRef, ComponentType, ConnectedPosition, CdkOverlayOrigin } from '@angular/cdk/overlay';
import { MatFormFieldAppearance } from '@angular/material/form-field';
import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
import { TooltipPosition } from '@angular/material/tooltip';
import { AnimationPlayer, AnimationTriggerMetadata } from '@angular/animations';
import { MatSnackBarConfig, MatSnackBarRef } from '@angular/material/snack-bar';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { MatInput } from '@angular/material/input';
import { ImageCroppedEvent } from 'ngx-image-cropper';
import { SafeHtml } from '@angular/platform-browser';

type IModsObject = Record<string, unknown>;
interface IBemConfig {
    separators: {
        el: string;
        mod: string;
        val: string;
    };
    ignoreValues?: boolean;
    modCase?: string;
}

declare class BlockDirective implements OnChanges {
    #private;
    readonly element: ElementRef;
    readonly renderer: Renderer2;
    readonly name: string;
    private readonly elem;
    rtMod?: string | string[] | (string | false)[] | IModsObject;
    constructor(element: ElementRef, renderer: Renderer2, name: string, elem: string);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BlockDirective, [null, null, { attribute: "rtBlock"; }, { attribute: "rtElem"; optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BlockDirective, "[rtBlock]", never, { "rtMod": { "alias": "rtMod"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ConcatClassesPipe implements PipeTransform {
    transform<C extends string | boolean | null | undefined>(classes: (C | C[])[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConcatClassesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ConcatClassesPipe, "concatClasses", true>;
}

declare class ElemDirective implements OnChanges {
    #private;
    readonly element: ElementRef;
    readonly renderer: Renderer2;
    readonly name: string;
    private readonly rtBlock;
    rtMod?: string | string[] | (string | false)[] | IModsObject;
    blockName: string;
    constructor(element: ElementRef, renderer: Renderer2, name: string, rtBlock: BlockDirective);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ElemDirective, [null, null, { attribute: "rtElem"; }, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ElemDirective, "[rtElem]", never, { "rtMod": { "alias": "rtMod"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ModDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ModDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ModDirective, "[rtMod]", never, {}, {}, never, never, true, never>;
}

declare enum STORAGE_TYPES_ENUM {
    LOCAL = "local",
    SESSION = "session",
    IN_MEMORY = "inMemory",
    CUSTOM = "custom"
}
type StorageType = STORAGE_TYPES_ENUM.LOCAL | STORAGE_TYPES_ENUM.SESSION | STORAGE_TYPES_ENUM.IN_MEMORY | STORAGE_TYPES_ENUM.CUSTOM;

/**
 * A service that implements the `Storage` interface using an in-memory map.
 * This service provides a fallback storage solution when `localStorage`
 * or `sessionStorage` is not available, such as in server-side rendering (SSR) scenarios.
 *
 * @Injectable
 */
declare class InMemoryStorageService implements Storage {
    #private;
    /**
     * Returns the number of key-value pairs currently stored.
     *
     * @returns the number of items in storage
     * @public
     */
    get length(): number;
    /**
     * Retrieves the value associated with the given key.
     *
     * @param key - The name of the key to retrieve the value for
     * @returns the value associated with the key, or `null` if the key does not exist
     * @public
     * @returns string | null
     */
    getItem(key: string): string | null;
    /**
     * Adds or updates the key-value pair in the storage.
     *
     * @param key - The name of the key to create or update
     * @param data - The value to associate with the key
     * @public
     * @returns void
     */
    setItem(key: string, data: string): void;
    /**
     * Retrieves the key at the specified index.
     *
     * @param index - The index of the key to retrieve
     * @returns the key at the specified index, or `null` if the index is out of bounds
     * @public
     * @returns string | null
     */
    key(index: number): string | null;
    /**
     * Removes the key-value pair associated with the given key.
     *
     * @param key - The name of the key to remove
     * @public
     * @returns void
     */
    removeItem(key: string): void;
    /**
     * Clears all key-value pairs from the storage.
     *
     * @public
     * @returns void
     */
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InMemoryStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InMemoryStorageService>;
}

type Nullable<T> = T | undefined | null;

interface IStorageConverter {
    convertTo(data: any): string;
    convertFrom<T>(data: any): Nullable<T>;
}

interface IStorageConfig {
    ctx: Nullable<StorageType>;
    storageRef: Nullable<Storage>;
    converter: Nullable<IStorageConverter>;
}

declare class JsonConverter implements IStorageConverter {
    convertTo(data: Nullable<any>): string;
    convertFrom<T>(data: any): Nullable<T>;
}

/**
 * Returns the set of dependency-injection providers
 * required to setup storages in an application.
 *
 * @usageNotes
 *
 * This function sets up the essential storage services needed for
 * working with `localStorage`, `sessionStorage`, and an in-memory storage solution.
 * It includes providers for each type of storage, ensuring that the appropriate
 * storage service is injected based on the platform or specific use case.
 *
 * The function is particularly useful in scenarios where the application may be
 * running on the server-side (SSR). In such cases, instead of using `localStorage`
 * and `sessionStorage`, which are only available in the browser, the `InMemoryStorageService`
 * can be used as a fallback, ensuring that the application still functions correctly.
 *
 * ```typescript
 * bootstrapApplication(RootComponent, {
 *   providers: [
 *     provideRtStorage()
 *   ]
 * });
 * ```
 *
 * @publicApi
 */
declare function provideRtStorage(): Provider[];

/**
 * Factory for creating or returning `localStorage`.
 * Returns `localStorage` global object if the application is running in a browser,
 * otherwise returns null.
 *
 * @returns localStorage or null
 */
declare function localStorageFactory(): Nullable<Storage>;
/**
 * Factory for creating or returning `sessionStorage`.
 * Returns `sessionStorage` global object if the application is running in a browser,
 * otherwise returns null.
 *
 * @returns sessionStorage or null
 */
declare function sessionStorageFactory(): Nullable<Storage>;
/**
 * Factory for creating `InMemoryStorageService`.
 * Returns a new instance of InMemoryStorageService.
 *
 * @returns a new instance of InMemoryStorageService
 */
declare function inMemoryStorageFactory(): Storage;

/**
 * A service for managing data storage across different storage types,
 * including `localStorage`, `sessionStorage`, and an in-memory storage fallback.
 * The service supports custom storage types and data conversion through configurable converters.
 *
 * @Injectable
 */
declare class StorageService {
    #private;
    /**
     * Retrieves an item from the specified storage context.
     *
     * @param key - The key of the item to retrieve.
     * @param config - Optional configuration for the storage context and data conversion.
     * @returns The retrieved item, converted from storage if a converter is provided, or `null` if the item does not exist.
     */
    getItem<T>(key: string, config?: Partial<IStorageConfig>): Nullable<T>;
    /**
     * Stores an item in the specified storage context.
     *
     * @param key - The key to associate with the stored item.
     * @param data - The data to store, which will be converted if a converter is provided.
     * @param config - Optional configuration for the storage context and data conversion.
     */
    setItem(key: string, data: any, config?: Partial<IStorageConfig>): void;
    /**
     * Checks if a given key exists in the specified storage context.
     *
     * @param key - The key to check for.
     * @param ctx - The storage context to search in (local, session, or in-memory).
     * @returns `true` if the key exists, `false` otherwise.
     */
    hasKey(key: string, ctx?: Nullable<StorageType>): boolean;
    /**
     * Executes callback functions based on whether a key exists in the specified storage context.
     *
     * @param key - The key to check for.
     * @param onHas - The callback to execute if the key exists.
     * @param onHasNot - The optional callback to execute if the key does not exist.
     * @param config - Optional configuration for the storage context and data conversion.
     */
    onHasKey<T>(key: string, onHas: (value: Nullable<T>) => void, onHasNot?: () => void, config?: Partial<IStorageConfig>): void;
    /**
     * Removes an item from the specified storage context.
     *
     * @param key - The key of the item to remove.
     * @param ctx - The storage context from which to remove the item.
     */
    removeItem(key: string, ctx?: Nullable<StorageType>): void;
    /**
     * Clears all items from the specified storage context.
     *
     * @param ctx - The storage context to clear.
     */
    clear(ctx?: Nullable<StorageType>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
}

declare const CUSTOM_STORAGE: InjectionToken<Storage>;

declare const IN_MEMORY_STORAGE: InjectionToken<Storage>;

declare const LOCAL_STORAGE: InjectionToken<Storage>;

declare const SESSION_STORAGE: InjectionToken<Storage>;

interface MessageBusEvent<T = string> {
    readonly type: T;
}
declare class MessageBus<M> {
    #private;
    emit(event: MessageBusEvent<M>): void;
    onEmit(): Observable<MessageBusEvent<M>>;
    ofType(eventType: M): Observable<MessageBusEvent<M>>;
}

interface IAction<T = string> extends MessageBusEvent<T> {
    readonly payload?: unknown;
}

interface IBaseStoreService<STATE_TYPE extends object, MSG_TYPE extends string> {
    store: Signal<STATE_TYPE>;
    dispatch: (event: IAction<MSG_TYPE>) => void;
    onDispatch: (msg: MSG_TYPE) => Observable<IAction<MSG_TYPE>>;
    patchState: (callbackFn: (state: STATE_TYPE) => STATE_TYPE) => void;
}

declare abstract class BaseStoreService<STATE_TYPE extends object, MSG_TYPE extends string> implements IBaseStoreService<STATE_TYPE, MSG_TYPE> {
    #private;
    readonly store: Signal<STATE_TYPE>;
    dispatch(event: IAction<MSG_TYPE>): void;
    onDispatch(msg: MSG_TYPE): Observable<IAction<MSG_TYPE>>;
    patchState(callbackFn: (state: STATE_TYPE) => STATE_TYPE): void;
    protected unsubscribe(): void;
}

/**
 * @description Enumeration indicates the current state of a request.
 * @value ModelStatus.Success - The request was successful.
 * @value ModelStatus.Error - The request failed.
 * @value ModelStatus.Init - The request has not been made yet.
 * @value ModelStatus.Pending - The request is in progress.
 */
declare enum ModelStatus {
    Init = 0,
    Pending = 1,
    Success = 2,
    Error = 3
}

interface ISetPropertiesConfig {
    showNotification?: boolean;
}
interface IBaseAsyncStoreService<STATE_TYPE extends object, MSG_TYPE extends string> extends IBaseStoreService<STATE_TYPE, MSG_TYPE> {
    /** @description Indicates status of the first request for getting list of Entities */
    loading: Signal<boolean>;
    /** @description Indicates status of the following requests for getting list of Entities */
    fetching: Signal<boolean>;
    /** @description Indicates status of all the requests for getting list of Entities */
    pending: Signal<boolean>;
    /** @description Indicates failure status of the first request for getting list of Entities */
    requestStatus: Signal<ModelStatus>;
    /** @description Indicates statuses of the first request for getting list of Entities */
    loadingStatus: Signal<ModelStatus>;
    /** @description Indicates statuses of the following requests for getting list of Entities */
    fetchingStatus: Signal<ModelStatus>;
    /** @description Indicates statuses of create/update requests */
    upsertStatus: Signal<ModelStatus>;
    /** @description Indicates statuses of delete requests */
    deleteStatus: Signal<ModelStatus>;
    handleError(error: HttpErrorResponse): void;
    /**
     * @description Resets the next props to initial values:
     * - loading,
     * - fetching,
     * - upsertStatus,
     * - deleteStatus,
     * - requestStatus
     */
    resetAsyncState(): void;
    startLoading(): void;
    setLoadingSuccess(): void;
    setLoadingFailure(error: HttpErrorResponse, config: ISetPropertiesConfig): Observable<never>;
    setLoadingFailureVoid(error: HttpErrorResponse, config: ISetPropertiesConfig): void;
    startFetching(): void;
    setFetchingSuccess(): void;
    setFetchingFailure(error: HttpErrorResponse, config: ISetPropertiesConfig): Observable<never>;
    setFetchingFailureVoid(error: HttpErrorResponse, config: ISetPropertiesConfig): void;
    /** @description Resets status for create/update requests */
    resetUpsertStatus(): void;
    startUpsert(): void;
    setUpsertSuccess(): void;
    setUpsertFailure(error: HttpErrorResponse, config: ISetPropertiesConfig): Observable<never>;
    setUpsertFailureVoid(error: HttpErrorResponse, config: ISetPropertiesConfig): void;
    /** @description Resets status for delete requests */
    resetDeleteStatus(): void;
    startDelete(): void;
    setDeleteSuccess(): void;
    setDeleteFailure(error: HttpErrorResponse, config: ISetPropertiesConfig): Observable<never>;
    setDeleteFailureVoid(error: HttpErrorResponse, config: ISetPropertiesConfig): void;
}

interface IDictionary<T> {
    [Key: string]: T;
}

type Primitive = string | number | bigint | boolean | symbol | null | undefined;

declare namespace IStateBase {
    interface Async {
        /** @description Indicates status of the first request for getting list of Entities */
        loading: boolean;
        /** @description Indicates status of the following requests for getting list of Entities */
        fetching: boolean;
        /** @description Indicates status of all the requests for getting list of Entities */
        pending: boolean;
        requestStatus: ModelStatus;
        loadingStatus: ModelStatus;
        fetchingStatus: ModelStatus;
        /** @description Indicates statuses of create/update requests */
        upsertStatus: ModelStatus;
        /** @description Indicates statuses of delete requests */
        deleteStatus: ModelStatus;
    }
    interface List<ENTITY_TYPE extends object, PAGE_MODEL_TYPE extends object, SORT_MODEL_TYPE extends object> extends Async {
        entities: ENTITY_TYPE[];
        pageModel: PAGE_MODEL_TYPE;
        sortModel: Nullable<SORT_MODEL_TYPE>;
        searchTerm: Nullable<string>;
        params: IDictionary<Primitive>;
    }
}

declare abstract class BaseAsyncStoreService<STATE_TYPE extends IStateBase.Async, MSG_TYPE extends string> extends BaseStoreService<STATE_TYPE, MSG_TYPE> implements IBaseAsyncStoreService<STATE_TYPE, MSG_TYPE> {
    readonly loading: Signal<boolean>;
    readonly fetching: Signal<boolean>;
    readonly pending: Signal<boolean>;
    readonly requestStatus: Signal<ModelStatus>;
    readonly loadingStatus: Signal<ModelStatus>;
    readonly fetchingStatus: Signal<ModelStatus>;
    readonly upsertStatus: Signal<ModelStatus>;
    readonly deleteStatus: Signal<ModelStatus>;
    protected constructor();
    handleError(error?: HttpErrorResponse, callbackFn?: () => void): void;
    resetAsyncState(): void;
    startLoading(): void;
    setLoadingSuccess(): void;
    setLoadingFailure(error: HttpErrorResponse, config?: ISetPropertiesConfig): Observable<never>;
    setLoadingFailureVoid(error: HttpErrorResponse, config?: ISetPropertiesConfig): void;
    startFetching(): void;
    setFetchingSuccess(): void;
    setFetchingFailure(error: HttpErrorResponse, config?: ISetPropertiesConfig): Observable<never>;
    setFetchingFailureVoid(error: HttpErrorResponse, config?: ISetPropertiesConfig): void;
    resetUpsertStatus(): void;
    startUpsert(): void;
    setUpsertSuccess(): void;
    setUpsertFailure(error: HttpErrorResponse, config?: ISetPropertiesConfig): Observable<never>;
    setUpsertFailureVoid(error: HttpErrorResponse, config?: ISetPropertiesConfig): void;
    resetDeleteStatus(): void;
    startDelete(): void;
    setDeleteSuccess(): void;
    setDeleteFailure(error: HttpErrorResponse, config?: ISetPropertiesConfig): Observable<never>;
    setDeleteFailureVoid(error: HttpErrorResponse, config?: ISetPropertiesConfig): void;
}

declare namespace BASE_INITIAL_STATE {
    const ASYNC: Readonly<IStateBase.Async>;
}

/**
 * Abstract StorageService class for interacting with a storage system.
 * Uses Observable to handle asynchronous operations.
 */
interface IIDBStorageServiceInterface<T> {
    /**
     * Retrieves a value from storage by the given key.
     * @param key - The key to retrieve the value.
     * @returns An Observable that emits the value of type T or undefined if the key does not exist.
     */
    get(key: string): Observable<T | undefined>;
    /**
     * Saves a value in storage under the specified key.
     * @param key - The key to store the value under.
     * @param value - The value to be stored.
     * @returns An Observable that completes once the value is successfully saved.
     */
    set(key: string, value: T): Observable<void>;
    /**
     * Removes a value from storage by the specified key.
     * @param key - The key to remove the value from.
     * @returns An Observable that completes once the value is successfully removed.
     */
    remove(key: string): Observable<void>;
}

declare class IDBStorageService<ENTITY_TYPE> implements IIDBStorageServiceInterface<ENTITY_TYPE> {
    #private;
    constructor();
    get(key: string): Observable<ENTITY_TYPE | undefined>;
    set(key: string, value: ENTITY_TYPE): Observable<void>;
    remove(key: string): Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IDBStorageService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IDBStorageService<any>>;
}

/**
 * Factory for creating `IDBStorageService`.
 * Returns a new instance of IDBStorageService.
 *
 * @returns a new instance of IDBStorageService
 */
declare function iDBStorageFactory(): IDBStorageService<Record<string, unknown>>;

/**
 * Returns the set of dependency-injection providers
 * required to set up storages in an application.
 *
 * @usageNotes
 *
 * This function sets up the essential storage services needed for
 * working with `idb storage` solution.
 * It includes providers for each type of storage, ensuring that the appropriate
 * storage service is injected based on the platform or specific use case.
 *
 * ```typescript
 * bootstrapApplication(RootComponent, {
 *   providers: [
 *     provideRtIDBStorage()
 *   ]
 * });
 * ```
 *
 * @publicApi
 */
declare function provideRtIDBStorage(): Provider[];

/**
 * Injection token for IDBStorageService.
 */
declare const IDB_STORAGE_SERVICE_TOKEN: InjectionToken<IDBStorageService<any>>;

interface Icon {
    value: string;
    style?: {
        [className: string]: string;
    };
}
interface Select<T> {
    value: Array<NameValueType<string, T>>;
    label?: string;
    hint?: string;
}
interface NameValueType<N = string, V = string> {
    name: N;
    value: V;
}

declare namespace IModal {
    interface Button<T> {
        text: string;
        color?: ThemePalette;
        value: Nullable<T>;
        appearance?: 'standard' | 'raised' | 'flat' | 'stroked' | 'fab' | 'mini-fab';
        validateSelect?: boolean;
        assignSelectedValue?: boolean;
        style?: {
            [className: string]: string;
        };
        className?: string;
    }
    interface Data<T> {
        buttonsAlign: 'start' | 'center' | 'end';
        buttons: Array<Button<T>>;
        component?: Type<any>;
        icon?: Icon;
        title?: string;
        text?: string;
        confirmation?: string;
        input?: {
            label: string;
            placeholder: string;
            value: string;
            sample?: string;
        };
        textArea?: {
            value: string;
            placeholder: string;
        };
        select?: Select<T>;
    }
    interface DataAnswer<T> {
        value: T;
        message: string;
    }
    type ConfirmResponsePredicate<T> = (answer: Nullable<IModal.DataAnswer<T>>) => boolean;
    interface ConfirmResponse<T> {
        on(predicate: ConfirmResponsePredicate<T>): Observable<Nullable<IModal.DataAnswer<T>>>;
        onCancel(cancel?: ConfirmResponsePredicate<T>): Observable<Nullable<IModal.DataAnswer<T>>>;
        onConfirm(confirm?: ConfirmResponsePredicate<T>): Observable<Nullable<IModal.DataAnswer<T>>>;
    }
}

declare class RtuiModalComponent<T> implements OnInit {
    #private;
    readonly data: IModal.Data<T>;
    control: FormControl | undefined;
    selectControl: FormControl | undefined;
    readonly bemBlock: string;
    get hostClasses(): Record<string, boolean>;
    ngOnInit(): void;
    onClose(button: IModal.Button<T>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiModalComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiModalComponent<any>, "rtui-modal", never, {}, {}, never, never, true, never>;
}

declare class RtModalService {
    #private;
    confirm<T>(data: IModal.Data<T>, config?: MatDialogConfig): Observable<Nullable<IModal.DataAnswer<T>>>;
    with<T>(data: IModal.Data<T>, config?: MatDialogConfig): IModal.ConfirmResponse<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RtModalService>;
}

/**
 * Date formatting and parsing utilities (replacement for date-fns)
 *
 * Supported format tokens:
 * - yyyy: 4-digit year (2024)
 * - yy: 2-digit year (24)
 * - MM: 2-digit month (01-12)
 * - M: month (1-12)
 * - dd: 2-digit day (01-31)
 * - d: day (1-31)
 * - HH: 2-digit hour 24h (00-23)
 * - H: hour 24h (0-23)
 * - hh: 2-digit hour 12h (01-12)
 * - h: hour 12h (1-12)
 * - mm: 2-digit minutes (00-59)
 * - m: minutes (0-59)
 * - ss: 2-digit seconds (00-59)
 * - s: seconds (0-59)
 * - SSS: milliseconds (000-999)
 * - a: AM/PM
 * - EEEE: full weekday name (Monday)
 * - EEE: short weekday name (Mon)
 * - MMMM: full month name (January)
 * - MMM: short month name (Jan)
 */
/**
 * Checks if a value is a valid Date object
 */
declare function isDate(value: unknown): value is Date;
/**
 * Formats a Date object according to the specified format string
 *
 * @param date - The date to format
 * @param formatStr - The format string (e.g., 'dd.MM.yyyy', 'yyyy-MM-dd HH:mm:ss')
 * @returns Formatted date string
 *
 * @example
 * formatDate(new Date(2024, 0, 15), 'dd.MM.yyyy') // '15.01.2024'
 * formatDate(new Date(2024, 0, 15, 14, 30), 'yyyy-MM-dd HH:mm') // '2024-01-15 14:30'
 */
declare function formatDate(date: Date, formatStr: string): string;
/**
 * Parses an ISO 8601 date string into a Date object
 *
 * @param dateString - ISO date string (e.g., '2024-01-15', '2024-01-15T14:30:00.000Z')
 * @returns Date object or Invalid Date if parsing fails
 *
 * @example
 * parseISO('2024-01-15') // Date object for Jan 15, 2024
 * parseISO('2024-01-15T14:30:00.000Z') // Date object with time
 */
declare function parseISO(dateString: string): Date;
/**
 * Parses a date string according to the specified format
 *
 * @param dateString - The date string to parse
 * @param formatStr - The format string describing the input
 * @param referenceDate - Reference date for missing parts (defaults to current date)
 * @returns Date object or Invalid Date if parsing fails
 *
 * @example
 * parseDate('15.01.2024', 'dd.MM.yyyy') // Date object for Jan 15, 2024
 * parseDate('2024/01/15 14:30', 'yyyy/MM/dd HH:mm') // Date with time
 */
declare function parseDate(dateString: string, formatStr: string, referenceDate?: Date): Date;

declare function dateStringToDate(date: string | Date): Date;

declare function isDateValid(date?: Date): boolean;

/**
 * Indicates if the arguments are equal
 *
 * @param f first parameter to compare
 * @param s second parameter to compare
 */
declare function isEqual<T>(f: T, s: T): boolean;
/**
 * Indicates if the content of two arrays is identical
 *
 * @param f first array
 * @param s second array
 */
declare function areArraysEqual<T>(f: T[], s: T[]): boolean;
/**
 * Indicates if the content of two objects is identical
 *
 * @param f first object
 * @param s second object
 */
declare function areObjectsEqual<T>(f: T, s: T): boolean;
/**
 * Checks whether two arrays are equal regardless of the order of their elements.
 * Supports deep comparison of nested arrays and objects.
 *
 * @template T The type of elements in the arrays
 * @param f first array
 * @param s second array
 * @returns True if the arrays contain the same elements in any order, false otherwise
 */
declare function areArraysEqualUnordered<T>(f: T[], s: T[]): boolean;

declare function isNumber<T>(value: T | number | unknown | undefined): value is number;

declare function isRecord(value: unknown): value is Record<string, unknown>;

declare function isString<T>(value: T | null | undefined | unknown): value is string;

declare function initToday(): Date;
declare function isToday(date: Date): boolean;

/** Makes shallow copy of passed object */
declare function removeFieldFromObject<T extends object, K extends string>(obj: T, key: K): Omit<T, K>;

type ComparatorType<T> = (aa: T, bb: T) => number;
/**
 * Allow to compare two values by provided comparator
 *
 * @param a - T
 * @param b - T
 * @param comparator - ComparatorType<T>
 */
declare function safeCompare<T>(a: T, b: T, comparator: ComparatorType<T>): number;
/**
 * Allow to safely compare two string values
 *
 * @param a string
 * @param b string
 */
declare function safeStrCompare(a: string, b: string): number;
/**
 * Allow to safely compare two number values
 *
 * @param a number
 * @param b number
 */
declare function safeNumCompare(a: number, b: number): number;
/**
 * Allow composing comparison chain of several comparators
 * that delegate comparison by the chain to the next comparators if current comparator returns 0
 *
 * @param comparators - Array<() => number>
 */
declare function safeComparatorPipe(...comparators: Array<() => number>): number;

declare const sortByAlphabet: <T extends object>(a: T, b: T, field: keyof T) => number;
declare const sortByDate: (a: {
    [field: string]: any;
}, b: {
    [field: string]: any;
}, field: string) => number;

declare function stringifyHttpLikeParams<T extends object>(params: T): {
    [param: string]: string | string[];
};

declare function transformArrayInput<T>(array: unknown): T[];

declare function transformStringInput(value: unknown): string;

declare function checkIsEntityInArrayByKey<ENTITY extends Record<string, unknown>, KEY extends Extract<keyof ENTITY, string>>(selectedEntities: ENTITY[], entity: ENTITY, keyExp: KEY): boolean;

declare function isNil<T>(entity: T | null | undefined): entity is null | undefined;

declare function emptyToDash<T>(value: T | null | undefined): T | string;

/**
 * Check if the email is valid
 * @param email
 */
declare function isEmail(email: any): boolean;

declare function isEmpty(value: unknown): boolean;

declare function isEmptyString(value: string): boolean;

declare function isEmptyArray<T>(value: T[]): boolean;

declare function isEmptyObject(value: Record<string, unknown>): boolean;

declare function debounce(timeout?: number): MethodDecorator;

declare enum HAS_OWN_SCOPE_ENUM {
    ANY = "any",
    OWN = "own",
    INHERITED = "inherited"
}
type IHasScopeType = HAS_OWN_SCOPE_ENUM.ANY | HAS_OWN_SCOPE_ENUM.OWN | HAS_OWN_SCOPE_ENUM.INHERITED;
/**
 * Safe property existence check with configurable scope.
 *
 * - Returns `false` for `null`/`undefined`.
 * - Boxes primitives (e.g., strings, numbers) so prototype checks work.
 * - Does **not** invoke getters; relies on `in` and an own-check helper.
 * - Uses `Object.hasOwn` when available; **falls back** to
 *   `Object.prototype.hasOwnProperty.call` on older runtimes.
 *
 * @param obj {unknown} - Value to check. `null`/`undefined` short-circuit to `false`.
 * @param key {PropertyKey} - Property key (string | number | symbol).
 * @param scope {IHasScopeType} - Check mode: `'any'` (default), `'own'`, or `'inherited'`.
 *
 * @returns `true` if the property exists under the selected scope.
 *
 * @example
 * hasPropertyInChain({ a: 1 }, 'a'); // true (ANY)
 * hasPropertyInChain(Object.create({ a: 1 }), 'a', HAS_OWN_SCOPE_ENUM.INHERITED); // true
 * hasPropertyInChain({ a: 1 }, 'b', HAS_OWN_SCOPE_ENUM.OWN); // false
 */
declare function hasPropertyInChain(obj: unknown, key: PropertyKey, scope?: IHasScopeType): boolean;

type AnyObject = Record<string, any>;
type EmptyObject = Record<string, never>;

type IntersectionType<T extends object, M extends object> = keyof T & keyof M;

type Modify<T, R> = Omit<T, keyof R> & R;

type PartialOmit<T, K extends keyof T> = Omit<T, K> & Partial<T>;

interface IMapper<I, M> {
    mapFrom(raw: I): M;
    mapTo?(model: M): I;
}

/** Makes selected props from a record optional */
type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

/** Get the union type of all the values in an object, array or array-like type */
type ValuesType<T extends ReadonlyArray<unknown> | ArrayLike<unknown> | Record<string | number | symbol, unknown>> = T extends ReadonlyArray<unknown> ? T[number] : T extends ArrayLike<unknown> ? T[number] : T extends object ? T[keyof T] : never;

declare class TypeCastHelper {
    getAsString(data: unknown, defaultValue?: string): string;
    getAsNumber(data: unknown, defaultValue?: number): number;
    getAsBoolean(data: unknown): boolean;
    getAsNull<T = unknown, R = T>(data: T, handler?: (data: T) => R): T | R | null;
    getAsType(value: unknown, type: NonNullable<unknown>): any;
    getAsTypedArray<T>(data: unknown[], cb: (item: unknown) => T, showError?: boolean): T[];
    getAsDate(date: string | number | Date, asString?: boolean, parseFormatOptions?: string, formatOptions?: string): Date | string;
}

interface IBaseMapper<M> {
    typeCast: TypeCastHelper;
    mapTo?: (model: M, ...args: any[]) => any;
    mapFrom?: (data: any, ...args: any[]) => M;
    mapToArray?: (models: M[], ...args: any[]) => any;
    mapFromArray?: (data: any[], ...args: any[]) => M[];
}

type Scriptable<T, TContext> = T | ((ctx: TContext, options: AnyObject) => T | undefined);
type ScriptableOptions<T, TContext> = {
    [P in keyof T]: Scriptable<T[P], TContext>;
};
type ScriptableAndScriptableOptions<T, TContext> = Scriptable<T, TContext> | ScriptableOptions<T, TContext>;
type ScriptableAndArray<T, TContext> = readonly T[] | Scriptable<T, TContext>;
type ScriptableAndArrayOptions<T, TContext> = {
    [P in keyof T]: ScriptableAndArray<T[P], TContext>;
};

declare namespace ISideMenu {
    type ItemData = string | number | object;
    interface Item {
        id: string | number;
        icon?: string;
        name?: string;
        link?: string;
        submenu?: Item[];
        iconButton?: {
            icon: string;
            data?: ItemData;
        };
    }
}

declare enum ASIDE_BUTTONS_ENUM {
    USER_ACTIVE = "User active",
    USER_INACTIVE = "User inactive",
    DELETE = "Delete",
    RESET = "Reset"
}
type AsideButtonsType = ASIDE_BUTTONS_ENUM.USER_ACTIVE | ASIDE_BUTTONS_ENUM.USER_INACTIVE | ASIDE_BUTTONS_ENUM.DELETE | ASIDE_BUTTONS_ENUM.RESET;

declare namespace IAside {
    interface HeaderActionButton {
        name: AsideButtonsType;
        icon: string;
        color: string;
        tooltip: string;
        disabled?: boolean;
    }
}

declare class BreakStringPipe implements PipeTransform {
    transform(value: Nullable<string>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreakStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BreakStringPipe, "breakString", true>;
}

declare class SanitizePipe implements PipeTransform {
    #private;
    transform(value: string): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizePipe, "sanitize", true>;
}

declare class EntityToStringPipe implements PipeTransform {
    transform<T>(value: T): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityToStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EntityToStringPipe, "entityToString", true>;
}

declare class EmptyToDashPipe implements PipeTransform {
    transform<T>(value: T | null | undefined): T | string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyToDashPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EmptyToDashPipe, "emptyToDash", true>;
}

/**
 * @description Use to compare equality to any of items with provided value
 * @example
 *
 * Direct usage
 * ```ts
 *   equalPipe.transform(100, 1, 10, 100) // => true
 * ```
 *
 * Template usage
 *
 * ```html
 *   <div *ngIf="100 | equal:1:10:100">Visible</div>
 * ```
 */
declare class EqualPipe implements PipeTransform {
    transform(value: any, ...compares: any[]): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EqualPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EqualPipe, "equal", true>;
}

/**
 * @description Use to access to the deep object state for comparison
 * @example
 *  {a: {b: true}} | equalChain:'a':'b':true => true
 */
declare class EqualChainPipe implements PipeTransform {
    transform(obj: object, ...args: any[]): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EqualChainPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EqualChainPipe, "equalChain", true>;
}

/**
 * @description Use to compare not equality to all items with provided value
 * @example
 *
 * Direct usage
 * ```ts
 *   notEqualPipe.transform(100, 1, 10, 100) // => false
 * ```
 *
 * Template usage
 *
 * ```html
 *   <div *ngIf="100 | notEqual:1:10:100">Invisible</div>
 * ```
 */
declare class NotEqualPipe implements PipeTransform {
    transform(value: any, ...compares: any[]): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotEqualPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NotEqualPipe, "notEqual", true>;
}

/**
 * @description Use to access to the deep object state for comparison
 * @example
 *  {a: {b: true}} | equalChain:'a':'b':false => true
 */
declare class NotEqualChainPipe implements PipeTransform {
    transform(obj: object, ...args: any[]): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotEqualChainPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NotEqualChainPipe, "notEqualChain", true>;
}

declare class TernaryPipe implements PipeTransform {
    transform(value: any, option1: any, option2: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<TernaryPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TernaryPipe, "ternary", true>;
}

/**
 * A service for detecting the platform on which the application is running.
 * This service is useful for checking if the application is running in a browser
 * environment or on the server-side.
 *
 * @Injectable
 */
declare class PlatformService {
    #private;
    readonly isPlatformBrowser: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformService>;
}

declare namespace OSTypes {
    const WINDOWS: string;
    const MAC_OS: string;
    const LINUX: string;
    const ANDROID: string;
    const IOS: string;
    const UNKNOWN: string;
}
declare class DeviceDetectorService {
    #private;
    userAgent: Nullable<string>;
    constructor();
    isMobile(): boolean;
    isTablet(): boolean;
    isDesktop(): boolean;
    getOS(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceDetectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceDetectorService>;
}

interface IBreakpoints {
    xl: string;
    lg: string;
    md: string;
    sm: string;
    xs: string;
}

/**
 * A service that manages responsive design breakpoints using Angular's `BreakpointObserver`.
 * This service provides signals for different screen sizes and allows dynamic
 * breakpoint management.
 *
 * @Injectable
 */
declare class BreakpointService {
    #private;
    readonly isDesktop: Signal<Nullable<boolean>>;
    readonly isSmallDesktop: Signal<Nullable<boolean>>;
    readonly isMobile: Signal<Nullable<boolean>>;
    readonly isTablet: Signal<Nullable<boolean>>;
    readonly isSmallTablet: Signal<Nullable<boolean>>;
    /**
     * Allows setting custom breakpoints for different screen sizes.
     *
     * @param breakpoints - The custom breakpoints to apply.
     */
    setBreakpoints(breakpoints: IBreakpoints): void;
    /**
     * Helper function to decrement the pixel value by 1.
     * Used to exclude the exact pixel value in media queries.
     *
     * @usageNotes
     *
     * This function is useful for setting correct media queries.
     * E.g. for mobile devices: media query should be `(max-width: 599px)`,
     * and from `(min-width: 600px)` it should be considered as a tablet.
     *
     * @param value - The pixel value to decrement.
     * @returns The adjusted pixel value as a string.
     */
    decrementOnePixel(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreakpointService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BreakpointService>;
}

declare class Breakpoints implements IBreakpoints {
    readonly xl: string;
    readonly lg: string;
    readonly md: string;
    readonly sm: string;
    readonly xs: string;
}

declare const WINDOW: InjectionToken<Window>;

type AsidePositions = 'left' | 'right';
declare class AsideRef<DATA, ANSWER> {
    private answer;
    overlayRef: OverlayRef;
    component: ComponentType<unknown>;
    position: AsidePositions;
    data: DATA;
    constructor(answer: Subject<ANSWER | null>, overlayRef: OverlayRef, component: ComponentType<unknown>, position: AsidePositions, data: DATA);
    close(answer?: ANSWER): void;
}
declare const ASIDE_REF: InjectionToken<AsideRef<object, object>>;
declare const ddServices: Array<{
    provide: string;
    useValue: unknown;
}>;

declare const NAVIGATOR: InjectionToken<Navigator>;

declare function checkIsMatchingValues(sample: string): ValidatorFn;

declare function arraysNotEmptyValidator(control: AbstractControl): ValidationErrors | null;

declare enum MODAL_WINDOW_SIZE_ENUM {
    SM = "25rem",
    MD = "45rem",
    LG = "65rem",
    FULL = "100%"
}
type ModalWindowSizeType = MODAL_WINDOW_SIZE_ENUM.SM | MODAL_WINDOW_SIZE_ENUM.MD | MODAL_WINDOW_SIZE_ENUM.LG | MODAL_WINDOW_SIZE_ENUM.FULL;

declare class RtIconOutlinedDirective {
    isOutlined: InputSignalWithTransform<boolean, BooleanInput>;
    get fontVariationSettings(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtIconOutlinedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtIconOutlinedDirective, "mat-icon[rtIconOutlined]", never, { "isOutlined": { "alias": "rtIconOutlined"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RtScrollToElementDirective {
    #private;
    rtScrollToElement: InputSignal<string | number>;
    elements: InputSignalWithTransform<unknown[], unknown[]>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<RtScrollToElementDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtScrollToElementDirective, "[rtScrollToElement]", never, { "rtScrollToElement": { "alias": "rtScrollToElement"; "required": true; "isSignal": true; }; "elements": { "alias": "elements"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RtHideTooltipDirective implements AfterViewInit {
    #private;
    /** Current HTMLElement */
    element: InputSignal<HTMLElement>;
    /** Indicates is tooltip shown */
    isTooltipShown: InputSignalWithTransform<boolean, boolean>;
    /** Set tooltip state by 'isTooltipShown' */
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtHideTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtHideTooltipDirective, "[rtHideTooltipDirective]", never, { "element": { "alias": "rtHideTooltipDirective"; "required": true; "isSignal": true; }; "isTooltipShown": { "alias": "isTooltipShown"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RtNavigationDirective {
    #private;
    link: InputSignal<Nullable<string>>;
    onClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtNavigationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtNavigationDirective, "[rtNavigationDirective]", never, { "link": { "alias": "rtNavigationDirective"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare abstract class RtTabQueryParamDirective implements OnInit {
    #private;
    readonly currentTabIndex: Signal<number>;
    ngOnInit(): void;
    setQueryTab(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtTabQueryParamDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtTabQueryParamDirective, never, never, {}, {}, never, never, true, never>;
}

declare class RtScrollDirective implements OnInit, OnDestroy {
    #private;
    active: InputSignal<boolean>;
    multiplier: InputSignal<number>;
    readonly scrollAction: OutputEmitterRef<void>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    scroll: EventListener;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtScrollDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtScrollDirective, "[rtScrollDirective]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "multiplier": { "alias": "multiplier"; "required": false; "isSignal": true; }; }, { "scrollAction": "scrollAction"; }, never, never, true, never>;
}

declare class RtEscapeKeyDirective {
    readonly escapeKeyAction: OutputEmitterRef<void>;
    handleKeyboardEvent(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtEscapeKeyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtEscapeKeyDirective, "[rtEscapeKey]", never, {}, { "escapeKeyAction": "escapeKeyAction"; }, never, never, true, never>;
}

declare abstract class BaseMapper<M> implements IBaseMapper<M> {
    readonly typeCast: TypeCastHelper;
    mapFrom(data: NonNullable<unknown>, ...args: unknown[]): M;
    mapFromArray(data: NonNullable<unknown>[], ...args: unknown[]): M[];
    mapTo(model: M, ...args: unknown[]): unknown;
    mapToArray(models: M[], ...args: unknown[]): unknown[];
}

declare const OVERLAY_POSITIONS: Readonly<ConnectedPosition[]>;

declare const DASH: string;

/**
 * Returns a set of dependency injection providers for utility services.
 *
 * @usageNotes
 *
 * This function provides utility services that are commonly used across
 * an Angular application. Specifically, it provides the `BreakpointService`
 * for managing responsive design breakpoints and the `PlatformService` for
 * detecting the platform on which the application is running (e.g., browser or server).
 *
 * ```typescript
 * bootstrapApplication(RootComponent, {
 *   providers: [
 *     provideRtUtils()
 *   ]
 * });
 * ```
 *
 * @publicApi
 */
declare function provideRtUtils(): Provider[];

declare class RtuiScrollableContainerHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiScrollableContainerHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiScrollableContainerHeaderDirective, "[rtuiScrollableHeader]", never, {}, {}, never, never, true, never>;
}
declare class RtuiScrollableContainerContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiScrollableContainerContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiScrollableContainerContentDirective, "[rtuiScrollableContent]", never, {}, {}, never, never, true, never>;
}
declare class RtuiScrollableContainerFooterDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiScrollableContainerFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiScrollableContainerFooterDirective, "[rtuiScrollableFooter]", never, {}, {}, never, never, true, never>;
}
declare class RtuiScrollableContainerComponent {
    readonly headerTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly contentTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly footerTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiScrollableContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiScrollableContainerComponent, "rtui-scrollable", never, {}, {}, ["headerTpl", "contentTpl", "footerTpl"], never, true, never>;
}

declare class RtuiSideMenuHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiSideMenuHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiSideMenuHeaderDirective, "[rtuiSideMenuHeader]", never, {}, {}, never, never, true, never>;
}
declare class RtuiSideMenuFooterDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiSideMenuFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiSideMenuFooterDirective, "[rtuiSideMenuFooter]", never, {}, {}, never, never, true, never>;
}
declare class RtuiSideMenuComponent {
    #private;
    readonly headerTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly footerTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly subMenuRef: Signal<Nullable<MatDrawer>>;
    readonly backToMainMenuButton: Signal<ISideMenu.Item>;
    readonly selectedItem: WritableSignal<Nullable<ISideMenu.Item>>;
    readonly selectedSubMenu: WritableSignal<Nullable<ISideMenu.Item[]>>;
    activeMenuIds: InputSignal<Array<string | number>>;
    menuItems: InputSignalWithTransform<ISideMenu.Item[], ISideMenu.Item[]>;
    isMobile: InputSignalWithTransform<Nullable<boolean>, Nullable<boolean>>;
    isSubMenuXScrollEnabled: InputSignalWithTransform<boolean, boolean>;
    isMainMenuIconsOutlined: InputSignalWithTransform<boolean, boolean>;
    isSubMenuIconsOutlined: InputSignalWithTransform<boolean, boolean>;
    isSubMenuButtonIconsOutlined: InputSignalWithTransform<boolean, boolean>;
    isSubMenuTooltipsShown: InputSignalWithTransform<boolean, boolean>;
    activeMenuId: Signal<number | string>;
    readonly closeMobileMenuAction: OutputEmitterRef<void>;
    readonly clickSubMenuAction: OutputEmitterRef<{
        item: ISideMenu.Item;
        event: MouseEvent;
    }>;
    readonly clickSubMenuAdditionalAction: OutputEmitterRef<{
        data: ISideMenu.ItemData;
        event: MouseEvent;
    }>;
    onClickMenu(item: ISideMenu.Item): void;
    onClickSubMenu({ item, event }: {
        item: ISideMenu.Item;
        event: MouseEvent;
    }): void;
    onBackToMainMenu(): void;
    toggleSubMenu(item?: ISideMenu.Item): void;
    closeSubMenu(): void;
    closeMobileMenu(): void;
    clickSubMenuAdditional({ data, event }: {
        data: ISideMenu.ItemData;
        event: MouseEvent;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiSideMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiSideMenuComponent, "rtui-side-menu", never, { "activeMenuIds": { "alias": "activeMenuIds"; "required": true; "isSignal": true; }; "menuItems": { "alias": "menuItems"; "required": false; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": false; "isSignal": true; }; "isSubMenuXScrollEnabled": { "alias": "isSubMenuXScrollEnabled"; "required": false; "isSignal": true; }; "isMainMenuIconsOutlined": { "alias": "isMainMenuIconsOutlined"; "required": false; "isSignal": true; }; "isSubMenuIconsOutlined": { "alias": "isSubMenuIconsOutlined"; "required": false; "isSignal": true; }; "isSubMenuButtonIconsOutlined": { "alias": "isSubMenuButtonIconsOutlined"; "required": false; "isSignal": true; }; "isSubMenuTooltipsShown": { "alias": "isSubMenuTooltipsShown"; "required": false; "isSignal": true; }; }, { "closeMobileMenuAction": "closeMobileMenuAction"; "clickSubMenuAction": "clickSubMenuAction"; "clickSubMenuAdditionalAction": "clickSubMenuAdditionalAction"; }, ["headerTpl", "footerTpl"], never, true, never>;
}

declare class RtuiSpinnerComponent {
    diameter: InputSignalWithTransform<number, number>;
    showBox: InputSignalWithTransform<boolean, boolean>;
    showBackground: InputSignalWithTransform<boolean, boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiSpinnerComponent, "rtui-spinner", never, { "diameter": { "alias": "diameter"; "required": false; "isSignal": true; }; "showBox": { "alias": "showBox"; "required": false; "isSignal": true; }; "showBackground": { "alias": "showBackground"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RtAsideService {
    #private;
    /**
     * Opens an aside panel with a specified component, position, and data.
     *
     * @template COMPONENT - The type of the component to display in the aside panel.
     * @template DATA - The type of the data to pass to the component.
     * @template ANSWER - The type of the response expected from the aside panel.
     *
     * @param component - The component to render inside the aside panel.
     * @param position - The position (left or right) where the aside panel should appear.
     * @param data - The data to pass to the component in the aside panel.
     *
     * @returns An observable that emits the response from the aside panel when it is closed.
     */
    Open<COMPONENT = null, DATA = null, ANSWER = null>(component: ComponentType$1<COMPONENT>, position: AsidePositions, data: DATA): Observable<ANSWER | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RtAsideService>;
}

declare class RtuiAsideContainerHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiAsideContainerHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiAsideContainerHeaderDirective, "[rtuiAsideHeader]", never, {}, {}, never, never, true, never>;
}
declare class RtuiAsideContainerComponent {
    title: InputSignal<Nullable<string>>;
    isMobile: InputSignalWithTransform<Nullable<boolean>, boolean>;
    isSubmitButtonDisabled: InputSignalWithTransform<boolean, boolean>;
    isFooterShown: InputSignalWithTransform<boolean, boolean>;
    pending: InputSignalWithTransform<boolean, boolean>;
    isRequestErrorShown: InputSignalWithTransform<boolean, boolean>;
    headerActionsButtons: InputSignalWithTransform<IAside.HeaderActionButton[], IAside.HeaderActionButton[]>;
    requestError: InputSignal<Nullable<HttpErrorResponse>>;
    submitButtonTitle: InputSignal<string>;
    cancelButtonTitle: InputSignal<string>;
    submitButtonTooltip: InputSignal<string>;
    readonly submitAction: OutputEmitterRef<void>;
    readonly cancelAction: OutputEmitterRef<void>;
    readonly headerAction: OutputEmitterRef<AsideButtonsType>;
    readonly headerTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    onSubmit(): void;
    onCancel(): void;
    onHeaderActionClick(buttonName: AsideButtonsType): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiAsideContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiAsideContainerComponent, "rtui-aside-container", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; "isSubmitButtonDisabled": { "alias": "isSubmitButtonDisabled"; "required": true; "isSignal": true; }; "isFooterShown": { "alias": "isFooterShown"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "isRequestErrorShown": { "alias": "isRequestErrorShown"; "required": false; "isSignal": true; }; "headerActionsButtons": { "alias": "headerActionsButtons"; "required": false; "isSignal": true; }; "requestError": { "alias": "requestError"; "required": false; "isSignal": true; }; "submitButtonTitle": { "alias": "submitButtonTitle"; "required": false; "isSignal": true; }; "cancelButtonTitle": { "alias": "cancelButtonTitle"; "required": false; "isSignal": true; }; "submitButtonTooltip": { "alias": "submitButtonTooltip"; "required": false; "isSignal": true; }; }, { "submitAction": "submitAction"; "cancelAction": "cancelAction"; "headerAction": "headerAction"; }, ["headerTpl"], ["*"], true, never>;
}

declare class RtuiRoundIconButtonComponent {
    icon: InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiRoundIconButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiRoundIconButtonComponent, "rtui-round-icon-button", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare enum BUTTON_SIZE {
    SMALL = "sm",
    MEDIUM = "md",
    LARGE = "lg",
    FULL = "full"
}
type ButtonSizeType = BUTTON_SIZE.SMALL | BUTTON_SIZE.MEDIUM | BUTTON_SIZE.LARGE | BUTTON_SIZE.FULL;
declare enum BUTTON_COLOR {
    ACCENT = "accent",
    SUCCESS = "success",
    SECONDARY = "secondary",
    ERROR = "error",
    WARNING = "warning"
}
type ButtonColorType = BUTTON_COLOR.ACCENT | BUTTON_COLOR.SUCCESS | BUTTON_COLOR.ERROR | BUTTON_COLOR.WARNING | BUTTON_COLOR.SECONDARY;
declare enum BUTTON_APPEARANCE {
    OUTLINE = "outline",
    LIGHT = "light"
}
type ButtonAppearanceType = BUTTON_APPEARANCE.OUTLINE | BUTTON_APPEARANCE.LIGHT;
declare class RtuiButtonComponent {
    readonly size: InputSignal<ButtonSizeType>;
    readonly color: InputSignal<ButtonColorType>;
    readonly appearance: InputSignal<Nullable<ButtonAppearanceType>>;
    readonly modifierClass: Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiButtonComponent, "a[rtui-btn], button[rtui-btn]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class RtuiMultiButtonComponent {
    actions: InputSignalWithTransform<string[], string[]>;
    activeAction: ModelSignal<string>;
    readonly changeActiveAction: OutputEmitterRef<string>;
    onSetActiveAction(action: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiMultiButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiMultiButtonComponent, "rtui-multi-button", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "activeAction": { "alias": "activeAction"; "required": false; "isSignal": true; }; }, { "activeAction": "activeActionChange"; "changeActiveAction": "changeActiveAction"; }, never, never, true, never>;
}

declare class RtuiToolbarLeftDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiToolbarLeftDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiToolbarLeftDirective, "[rtuiToolbarLeft]", never, {}, {}, never, never, true, never>;
}
declare class RtuiToolbarCenterDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiToolbarCenterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiToolbarCenterDirective, "[rtuiToolbarCenter]", never, {}, {}, never, never, true, never>;
}
declare class RtuiToolbarRightDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiToolbarRightDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiToolbarRightDirective, "[rtuiToolbarRight]", never, {}, {}, never, never, true, never>;
}
declare class RtuiToolbarComponent {
    isVisibleToolbar: Signal<boolean>;
    readonly leftToolTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly centerToolTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly rightToolTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    sticky: InputSignalWithTransform<Nullable<boolean>, boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiToolbarComponent, "rtui-toolbar", never, { "isVisibleToolbar": { "alias": "isVisibleToolbar"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, ["leftToolTpl", "centerToolTpl", "rightToolTpl"], never, true, never>;
}

declare class RtuiHeaderLeftDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiHeaderLeftDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiHeaderLeftDirective, "[rtuiHeaderLeft]", never, {}, {}, never, never, true, never>;
}
declare class RtuiHeaderCenterDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiHeaderCenterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiHeaderCenterDirective, "[rtuiHeaderCenter]", never, {}, {}, never, never, true, never>;
}
declare class RtuiHeaderRightDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiHeaderRightDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiHeaderRightDirective, "[rtuiHeaderRight]", never, {}, {}, never, never, true, never>;
}
declare class RtuiHeaderComponent {
    isMobile: InputSignalWithTransform<Nullable<boolean>, Nullable<boolean>>;
    isMobileMenuButtonShown: InputSignalWithTransform<Nullable<boolean>, Nullable<boolean>>;
    readonly leftHeaderTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly centerHeaderTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly rightHeaderTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    readonly openMobileMenuAction: OutputEmitterRef<void>;
    openSideMenu(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiHeaderComponent, "rtui-header", never, { "isMobile": { "alias": "isMobile"; "required": false; "isSignal": true; }; "isMobileMenuButtonShown": { "alias": "isMobileMenuButtonShown"; "required": false; "isSignal": true; }; }, { "openMobileMenuAction": "openMobileMenuAction"; }, ["leftHeaderTpl", "centerHeaderTpl", "rightHeaderTpl"], never, true, never>;
}

declare class RtuiClearButtonComponent {
    #private;
    isMobile: InputSignalWithTransform<Nullable<boolean>, boolean>;
    isButtonShown: InputSignalWithTransform<Nullable<boolean>, boolean>;
    tooltip: InputSignalWithTransform<Nullable<string>, string>;
    tooltipPosition: InputSignal<TooltipPosition>;
    readonly keydownAction: OutputEmitterRef<void>;
    readonly clickAction: OutputEmitterRef<void>;
    onKeydown(): void;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiClearButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiClearButtonComponent, "rtui-clear-button", never, { "isMobile": { "alias": "isMobile"; "required": false; "isSignal": true; }; "isButtonShown": { "alias": "isButtonShown"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, { "keydownAction": "keydownAction"; "clickAction": "clickAction"; }, never, never, true, never>;
}

declare enum LIST_SORT_ORDER_ENUM {
    ASC = "asc",
    DESC = "desc"
}
type ListSortOrderType = LIST_SORT_ORDER_ENUM.ASC | LIST_SORT_ORDER_ENUM.DESC;

interface ListState<T extends string, M extends object> {
    pageModel: PageModel;
    sortModel: SortModel<T>;
    filterModel: M;
    searchTerm: string;
}
interface SortModel<T = string> {
    propertyName: T;
    sortDirection: ListSortOrderType;
}
interface PageModel {
    pageNumber: number;
    pageSize: number;
    totalCount: number;
    endIndex?: number;
    hasNext?: boolean;
    hasPrev?: boolean;
    isFirstPage?: boolean;
    isLastPage?: boolean;
    startIndex?: number;
}
interface FilterModel<M = string> {
    operatorType: FilterOperatorType;
    propertyName: M;
    value?: string | number | boolean;
    values?: Array<string | number>;
}
declare enum FILTER_OPERATOR_TYPE_ENUM {
    EQUALS = "equals",
    NOT_EQUALS = "notEquals",
    STARTS_WITH = "startsWith",
    ENDS_WITH = "endsWith",
    CONTAINS = "contains",
    GREATER_THAN = "greaterThan",
    LESS_THAN = "lessThan"
}
type FilterOperatorType = FILTER_OPERATOR_TYPE_ENUM.EQUALS | FILTER_OPERATOR_TYPE_ENUM.NOT_EQUALS | FILTER_OPERATOR_TYPE_ENUM.STARTS_WITH | FILTER_OPERATOR_TYPE_ENUM.ENDS_WITH | FILTER_OPERATOR_TYPE_ENUM.CONTAINS | FILTER_OPERATOR_TYPE_ENUM.GREATER_THAN | FILTER_OPERATOR_TYPE_ENUM.LESS_THAN;
declare const FILTER_OPERATORS: ReadonlyArray<FilterOperatorType>;

declare class RtuiPaginationComponent implements OnInit, AfterViewInit {
    #private;
    /** Current Page Model */
    currentPageModel: InputSignal<PageModel>;
    /** Indicates is mobile view */
    isMobile: InputSignalWithTransform<Nullable<boolean>, boolean>;
    /** Output action when Page Model changed */
    readonly pageModelChange: OutputEmitterRef<Partial<PageModel>>;
    /** Form control for selected page size */
    control: FormControl<number>;
    readonly divider: Signal<string>;
    /** Page size options */
    readonly pageSizes: Signal<number[]>;
    /** Array of current page numbers */
    readonly numbers: WritableSignal<Array<number | string>>;
    /** Page Model for compare */
    readonly previousPageModel: WritableSignal<Nullable<PageModel>>;
    /** Value of full content width */
    readonly minContentFitWidth: WritableSignal<number>;
    /** Indicates is content clipped */
    readonly isContentClipped: WritableSignal<boolean>;
    /** Container template ref */
    readonly containerRef: Signal<Nullable<ElementRef<HTMLElement>>>;
    /** Set 'isContentClipped' when widow resize */
    onResize(): void;
    ngOnInit(): void;
    /** Set 'isContentClipped' on init */
    ngAfterViewInit(): void;
    /** Action for change Page Model */
    changePageSize(pageSize: number): void;
    /** Action for select page */
    onChangePageNumber(pageNumber: string | number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiPaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiPaginationComponent, "rtui-pagination", never, { "currentPageModel": { "alias": "currentPageModel"; "required": true; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; }, { "pageModelChange": "pageModelChange"; }, never, never, true, never>;
}

declare const RTUI_TABLE_STOP_ROW_CLICK_ATTRIBUTE: string;

declare const DEFAULT_PAGE_SIZE: number;
declare const DEFAULT_PAGE_MODEL: Readonly<PageModel>;

declare enum TABLE_COLUMN_TYPES_ENUM {
    DATE = "date",
    PERCENT = "percent",
    ARRAY = "array",
    BOOLEAN = "boolean",
    TEXT = "text",
    CURRENCY = "currency",
    CUSTOM = "custom"
}
declare enum TABLE_COLUMN_FILTER_TYPES_ENUM {
    TEXT = "text",
    NUMBER = "number",
    SELECT = "select",
    DATE = "date"
}
declare enum TEXT_CELL_COLOR_ENUM {
    NEUTRAL = "neutral",
    DANGER = "danger",
    WARNING = "warning",
    SUCCESS = "success",
    EMPTY = "empty"
}
declare namespace ITable {
    type TextCellColor = TEXT_CELL_COLOR_ENUM.NEUTRAL | TEXT_CELL_COLOR_ENUM.DANGER | TEXT_CELL_COLOR_ENUM.WARNING | TEXT_CELL_COLOR_ENUM.SUCCESS | TEXT_CELL_COLOR_ENUM.EMPTY;
    type Type = TABLE_COLUMN_TYPES_ENUM.DATE | TABLE_COLUMN_TYPES_ENUM.PERCENT | TABLE_COLUMN_TYPES_ENUM.ARRAY | TABLE_COLUMN_TYPES_ENUM.BOOLEAN | TABLE_COLUMN_TYPES_ENUM.TEXT | TABLE_COLUMN_TYPES_ENUM.CURRENCY | TABLE_COLUMN_TYPES_ENUM.CUSTOM;
    type FilterType = TABLE_COLUMN_FILTER_TYPES_ENUM.TEXT | TABLE_COLUMN_FILTER_TYPES_ENUM.NUMBER | TABLE_COLUMN_FILTER_TYPES_ENUM.SELECT | TABLE_COLUMN_FILTER_TYPES_ENUM.DATE;
    interface Column<T = Record<string, unknown>> extends Record<string, unknown> {
        align: 'right' | 'left' | 'center';
        propName: keyof T;
        type: Type;
        copyable: boolean;
        header: Header;
        sorting?: SortModel<NonNullable<Extract<keyof T, string>>>;
        filtering?: boolean;
        filteringMultiple?: boolean;
        copyBtnAlign?: 'right' | 'left';
        width?: string;
        minWidth?: string;
        icon?: Icon;
        iconTransform?: (value: T[keyof T]) => string;
        href?: string;
        className?: string;
        tooltip?: string;
        transform?: (value: T[keyof T]) => string | number;
        filterType?: FilterType;
        defaultFilterOperator?: FilterOperatorType;
        filterOperators?: FilterOperatorType[];
        filterSelectOptions?: string[];
        displayName?: string;
        orderIndex?: number;
        hidden?: boolean;
        fixed?: boolean;
    }
    interface ColumnFilter {
        propName: string;
        value: string;
    }
    interface Header {
        align: 'right' | 'left' | 'center';
        label: string;
        className?: string;
        tooltip?: string;
        icon?: Icon;
    }
    interface Icon {
        glyph: string;
        color?: TextCellColor;
        tooltip?: string;
        visible?: boolean;
        placement?: 'left' | 'right';
        outlined?: boolean;
    }
    namespace Config {
        interface Data<T> {
            isVerticalScrollbarShown: boolean;
            isHorizontalScrollbarShown: boolean;
            columns: Array<ITable.Column<T>>;
        }
        interface Form<T> {
            isVerticalScrollbarShown: FormControl<boolean>;
            isHorizontalScrollbarShown: FormControl<boolean>;
            columns: FormControl<(keyof T)[]>;
        }
    }
}

declare const RTUI_TABLE_COMPONENT_TOKEN: InjectionToken<IRtuiTable<Record<string, unknown>, string, string>>;
interface IRtuiTable<ENTITY_TYPE extends Record<string, unknown>, SORT_PROPERTY extends Extract<keyof ENTITY_TYPE, string>, KEY extends Extract<keyof ENTITY_TYPE, string>> {
    columns: Signal<Array<ITable.Column<ENTITY_TYPE>>>;
    customCellsTpl: Signal<Nullable<{
        getTemplateByPropName(propName: keyof ENTITY_TYPE): TemplateRef<{
            $implicit: ENTITY_TYPE;
        }>;
    }>>;
    rowActionsTpl: Signal<Nullable<TemplateRef<{
        $implicit: ENTITY_TYPE;
    }>>>;
    additionalRowActionsTpl: Signal<Nullable<TemplateRef<unknown>>>;
    isMobile: Signal<boolean>;
    isTableRowsClickable: Signal<boolean>;
    keyExp: Signal<NonNullable<KEY>>;
    entities: Signal<ENTITY_TYPE[]>;
    currentSortModel: Signal<Nullable<SortModel<SORT_PROPERTY>>>;
    appearance: Signal<MatFormFieldAppearance>;
    filterAppearance: Signal<MatFormFieldAppearance>;
    filterModel: Signal<FilterModel<KEY>[]>;
    isFiltersShown: Signal<boolean>;
    selectedEntitiesIds: WritableSignal<ENTITY_TYPE[KEY][]>;
    isPageEntitiesSelected: WritableSignal<boolean>;
    isPageEntitiesIndeterminate: WritableSignal<boolean>;
    isMultiSelect: WritableSignal<boolean>;
    isSelectorsColumnShown: WritableSignal<boolean>;
    isSelectorsColumnDisabled: WritableSignal<boolean>;
    activeRowIndex: WritableSignal<Nullable<number>>;
    onSortChange(sortModel: SortModel): void;
    onFilterChange(filterModel: FilterModel<KEY>[]): void;
    onMenuOpen(index: number): void;
    onMenuClose(): void;
    onRowClick(row: ENTITY_TYPE, event: MouseEvent): void;
    onRowDoubleClick(row: ENTITY_TYPE): void;
    onToggleEntity(entity: ENTITY_TYPE, checked: boolean): void;
    onTogglePageEntities(checked: boolean): void;
}

declare class RtTableConfigService<ENTITY_TYPE> {
    #private;
    readonly tableConfig: Signal<ITable.Config.Data<ENTITY_TYPE>>;
    initConfig(storageKey: string, config: Array<ITable.Column<ENTITY_TYPE>>): void;
    updateConfig(storageKey: string, config: ITable.Config.Data<ENTITY_TYPE>): void;
    deleteConfig(storageKey: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtTableConfigService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RtTableConfigService<any>>;
}

declare class RtCommonSelectorsDirective<ENTITY_TYPE extends Record<string, unknown>, KEY extends Extract<keyof ENTITY_TYPE, string>> {
    /** Indicates is multiselect available */
    isMultiSelect: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is 'Select all' checkbox shown  */
    isSelectorColumnShown: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is selectors column disabled */
    isSelectorsColumnDisabled: InputSignalWithTransform<boolean, boolean>;
    /** Selected entities Ids on init */
    selectedEntitiesKeys: InputSignalWithTransform<ENTITY_TYPE[KEY][], ENTITY_TYPE[KEY][]>;
    /** Key of ENTITY_TYPE for compare entities */
    readonly keyExp: WritableSignal<NonNullable<KEY>>;
    /** Current list of entities */
    readonly entities: WritableSignal<ENTITY_TYPE[]>;
    /** Add page entities to list exclude duplicates */
    addPageEntitiesToListExcludeDuplicates(list: ENTITY_TYPE[]): ENTITY_TYPE[];
    /** Remove page entities from list */
    removePageEntitiesFromList(list: ENTITY_TYPE[]): ENTITY_TYPE[];
    /** Check is one of page entities exist in selected entities */
    isOneExistOnPage(selectedEntitiesIds: ENTITY_TYPE[KEY][]): boolean;
    /** Check is all page entities exist in selected entities */
    isAllExistOnPage(selectedEntitiesIds: ENTITY_TYPE[KEY][]): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtCommonSelectorsDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtCommonSelectorsDirective<any, any>, never, never, { "isMultiSelect": { "alias": "isMultiSelect"; "required": false; "isSignal": true; }; "isSelectorColumnShown": { "alias": "isSelectorColumnShown"; "required": false; "isSignal": true; }; "isSelectorsColumnDisabled": { "alias": "isSelectorsColumnDisabled"; "required": false; "isSignal": true; }; "selectedEntitiesKeys": { "alias": "selectedEntitiesKeys"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RtDynamicListSelectorsDirective<ENTITY_TYPE extends Record<string, unknown>, SORT_PROPERTY extends Extract<keyof ENTITY_TYPE, string>, KEY extends Extract<keyof ENTITY_TYPE, string>> extends RtCommonSelectorsDirective<ENTITY_TYPE, KEY> implements OnInit {
    #private;
    /** Indicates is multiselect extended mod available (use selected and excluded lists) */
    isMultiSelectExtendedMod: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is 'Select all' checkbox shown  */
    isSelectAllSelectorShown: InputSignalWithTransform<boolean, boolean>;
    /** List of selected entities */
    readonly selectedEntities: Signal<ENTITY_TYPE[]>;
    /** List of excluded entities */
    readonly excludedEntities: Signal<ENTITY_TYPE[]>;
    /** List of selected entities ids */
    readonly selectedEntitiesIds: Signal<ENTITY_TYPE[KEY][]>;
    /** List of excluded entities ids */
    readonly excludedEntitiesIds: Signal<ENTITY_TYPE[KEY][]>;
    /** Indicates is 'Select All' checkbox selected */
    readonly isAllEntitiesSelected: Signal<boolean>;
    /** Indicates is all page entities checkbox selected */
    readonly isPageEntitiesSelected: Signal<boolean>;
    /** Indicates is page entities checkbox indeterminate */
    readonly isPageEntitiesIndeterminate: Signal<boolean>;
    /** Indicates is multi select extended mod enabled */
    readonly isMultiSelectExtendedModEnabled: Signal<boolean>;
    ngOnInit(): void;
    /** Change selected entities list and 'isAllEntitiesSelected' indicator state */
    toggleAllEntities(checked: boolean): void;
    /** Change selected and excluded lists, set 'isPageEntitiesSelected' and 'isAllEntitiesSelected' indicators states */
    togglePageEntities(checked: boolean): void;
    /** Change selected and excluded lists and set is existing selected and is all selected states */
    toggleEntity(entity: ENTITY_TYPE, checked: boolean): void;
    /** Clear selected list */
    clearSelectedList(): void;
    /** Clear excluded list */
    clearExcludedList(): void;
    /** Set is existing selected and indeterminate state */
    setExistingEntitiesState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtDynamicListSelectorsDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtDynamicListSelectorsDirective<any, any, any>, "rtui-dynamic-list[rtDynamicListSelectorsDirective]", never, { "isMultiSelectExtendedMod": { "alias": "isMultiSelectExtendedMod"; "required": false; "isSignal": true; }; "isSelectAllSelectorShown": { "alias": "isSelectAllSelectorShown"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RtTableSelectorsDirective<ENTITY_TYPE extends Record<string, unknown>, SORT_PROPERTY extends Extract<keyof ENTITY_TYPE, string>, KEY extends Extract<keyof ENTITY_TYPE, string>> extends RtCommonSelectorsDirective<ENTITY_TYPE, KEY> implements OnInit {
    #private;
    /** List of selected entities */
    readonly selectedEntities: Signal<ENTITY_TYPE[]>;
    /** List of selected entities ids */
    readonly selectedEntitiesIds: Signal<ENTITY_TYPE[KEY][]>;
    /** Indicates is all page entities checkbox selected */
    readonly isPageEntitiesSelected: Signal<boolean>;
    /** Indicates is page entities checkbox indeterminate */
    readonly isPageEntitiesIndeterminate: Signal<boolean>;
    ngOnInit(): void;
    /** Change selected and excluded lists, set 'isPageEntitiesSelected' and 'isAllEntitiesSelected' indicators states */
    togglePageEntities(checked: boolean): void;
    /** Change selected and excluded lists and set is existing selected and is all selected states */
    toggleEntity(entity: ENTITY_TYPE, checked: boolean): void;
    /** Clear selected list */
    clearSelectedList(): void;
    /** Set is existing selected and indeterminate state */
    setExistingEntitiesState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtTableSelectorsDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtTableSelectorsDirective<any, any, any>, "rtui-table[rtTableSelectorsDirective]", never, {}, {}, never, never, true, never>;
}

/** Directive for custom table cells */
declare class RtuiCustomTableCellsDirective<ENTITY_TYPE> {
    cellsTemplates: InputSignal<{
        [K in keyof ENTITY_TYPE]: TemplateRef<{
            $implicit: ENTITY_TYPE;
        }>;
    }>;
    getTemplateByPropName(propName: keyof ENTITY_TYPE): TemplateRef<{
        $implicit: ENTITY_TYPE;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiCustomTableCellsDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiCustomTableCellsDirective<any>, "[rtuiCustomTableCellsDirective]", never, { "cellsTemplates": { "alias": "rtuiCustomTableCellsDirective"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
/** Directive for row actions located inside a row menu button */
declare class RtuiTableRowActionsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiTableRowActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiTableRowActionsDirective, "[rtuiTabletRowActionsDirective]", never, {}, {}, never, never, true, never>;
}
/** Directive for row actions located outside a row menu button */
declare class RtuiTableAdditionalRowActionsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiTableAdditionalRowActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiTableAdditionalRowActionsDirective, "[rtuiTableAdditionalRowActionsDirective]", never, {}, {}, never, never, true, never>;
}
declare class RtuiTableComponent<ENTITY_TYPE extends Record<string, unknown>, SORT_PROPERTY extends Extract<keyof ENTITY_TYPE, string>, KEY extends Extract<keyof ENTITY_TYPE, string>> implements IRtuiTable<ENTITY_TYPE, SORT_PROPERTY, KEY>, AfterViewChecked {
    #private;
    protected readonly rowActions: Signal<Nullable<ElementRef<HTMLElement>>>;
    protected readonly rowActionsHeaderPaddingHelper: Signal<Nullable<ElementRef<HTMLElement>>>;
    protected readonly rowActionsPaddingHelper: Signal<Nullable<ElementRef<HTMLElement>>>;
    protected readonly columnTypes: typeof TABLE_COLUMN_TYPES_ENUM;
    protected readonly filterOperators: typeof FILTER_OPERATOR_TYPE_ENUM;
    /** Indicates is mobile view */
    isMobile: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates are table rows clickable */
    isTableRowsClickable: InputSignalWithTransform<boolean, BooleanInput>;
    /** Key of ENTITY_TYPE for compare entities */
    keyExp: InputSignal<NonNullable<KEY>>;
    /** List of entities */
    entities: InputSignalWithTransform<ENTITY_TYPE[], ENTITY_TYPE[]>;
    /** Current page model from store */
    currentSortModel: InputSignal<Nullable<SortModel<SORT_PROPERTY>>>;
    /** Current elements appearance */
    appearance: InputSignal<MatFormFieldAppearance>;
    /** Filter inputs appearance */
    filterAppearance: InputSignal<MatFormFieldAppearance>;
    /** Current filter model from store */
    filterModel: InputSignalWithTransform<FilterModel<KEY>[], FilterModel<KEY>[]>;
    /** Indicates is filters shown */
    isFiltersShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Row click output action */
    readonly rowClick: OutputEmitterRef<NonNullable<{
        row: ENTITY_TYPE;
        event: MouseEvent;
    }>>;
    /** Row doubleClick output action */
    readonly rowDoubleClick: OutputEmitterRef<NonNullable<ENTITY_TYPE>>;
    /** Sort change output action */
    readonly sortChange: OutputEmitterRef<SortModel<SORT_PROPERTY>>;
    /** Filter change output action */
    readonly filterChange: OutputEmitterRef<FilterModel<KEY>[]>;
    /** Columns config for table */
    columns: Signal<Array<ITable.Column<ENTITY_TYPE>>>;
    /** Custom cells template */
    readonly customCellsTpl: Signal<Nullable<RtuiCustomTableCellsDirective<ENTITY_TYPE>>>;
    /** Row actions template */
    readonly rowActionsTpl: Signal<Nullable<TemplateRef<{
        $implicit: ENTITY_TYPE;
    }>>>;
    /** Additional row actions template */
    readonly additionalRowActionsTpl: Signal<Nullable<TemplateRef<RtuiTableAdditionalRowActionsDirective>>>;
    /** Fields specified by the directive */
    /** List of selected entities ids */
    readonly selectedEntitiesIds: WritableSignal<ENTITY_TYPE[KEY][]>;
    /** Indicates are all page entities selected */
    readonly isPageEntitiesSelected: WritableSignal<boolean>;
    /** Indicates are some page entities selected */
    readonly isPageEntitiesIndeterminate: WritableSignal<boolean>;
    /** Indicates is multiselect mod enabled */
    readonly isMultiSelect: WritableSignal<boolean>;
    /** Indicates is selectors column shown */
    readonly isSelectorsColumnShown: WritableSignal<boolean>;
    /** Indicates is selectors column disabled */
    readonly isSelectorsColumnDisabled: WritableSignal<boolean>;
    /** Current row index */
    readonly activeRowIndex: WritableSignal<Nullable<number>>;
    ngAfterViewChecked(): void;
    /** Sort change output action */
    onSortChange(sortModel: SortModel<string>): void;
    /** Filter change output action */
    onFilterChange(filterModel: FilterModel<KEY>[]): void;
    /** Open row actions menu */
    onMenuOpen(index: number): void;
    /** Close the row actions menu */
    onMenuClose(): void;
    /** Row click output actions */
    onRowClick(row: NonNullable<ENTITY_TYPE>, event: MouseEvent): void;
    /** Row doubleClick output action */
    onRowDoubleClick(row: NonNullable<ENTITY_TYPE>): void;
    /** Empty methods set in selectors directive */
    onToggleEntity: (entity: ENTITY_TYPE, checked: boolean) => void;
    onTogglePageEntities: (checked: boolean) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiTableComponent<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiTableComponent<any, any, any>, "rtui-table", never, { "isMobile": { "alias": "isMobile"; "required": false; "isSignal": true; }; "isTableRowsClickable": { "alias": "isTableRowsClickable"; "required": false; "isSignal": true; }; "keyExp": { "alias": "keyExp"; "required": false; "isSignal": true; }; "entities": { "alias": "entities"; "required": true; "isSignal": true; }; "currentSortModel": { "alias": "currentSortModel"; "required": true; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": true; "isSignal": true; }; "filterAppearance": { "alias": "filterAppearance"; "required": false; "isSignal": true; }; "filterModel": { "alias": "filterModel"; "required": false; "isSignal": true; }; "isFiltersShown": { "alias": "isFiltersShown"; "required": false; "isSignal": true; }; }, { "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "sortChange": "sortChange"; "filterChange": "filterChange"; }, ["customCellsTpl", "rowActionsTpl", "additionalRowActionsTpl"], never, true, never>;
}

declare class RtuiTableContainerComponent<ENTITY_TYPE> implements OnInit {
    #private;
    appearance: InputSignal<MatFormFieldAppearance>;
    /** Table config storage key */
    tableConfigStorageKey: InputSignalWithTransform<string, string>;
    /** Current page model from store */
    pageModel: InputSignal<PageModel>;
    /** Indicates is mobile view */
    isMobile: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is loading in progress */
    loading: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is fetching in progress */
    fetching: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is placeholder shown */
    isPlaceholderShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is pagination shown */
    isPaginationShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is the refresh button shown */
    isRefreshButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is a table config button shown */
    isTableConfigButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is toolbar buttons outlined */
    isToolbarActionsIconsOutlined: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is filters shown */
    isFiltersShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is filters empty */
    isFiltersEmpty: InputSignalWithTransform<boolean, BooleanInput>;
    /** Current search term from store */
    searchTerm: InputSignalWithTransform<Nullable<string>, Nullable<string>>;
    /** Current placeholder icon */
    placeholderIcon: InputSignal<string>;
    /** Current placeholder title */
    placeholderTitle: InputSignal<string>;
    /** Indicates is a small tablet view */
    readonly isSmallTablet: Signal<Nullable<boolean>>;
    /** Config for table */
    readonly tableConfig: Signal<ITable.Config.Data<ENTITY_TYPE>>;
    /** Page model change output action */
    readonly pageModelChange: OutputEmitterRef<Partial<PageModel>>;
    /** Search change output action */
    readonly searchChange: OutputEmitterRef<Nullable<string>>;
    /** Refresh output action */
    readonly refreshAction: OutputEmitterRef<void>;
    /** Clear filters output action */
    readonly clearFiltersAction: OutputEmitterRef<void>;
    /** Toolbar selectors template */
    readonly toolbarSelectorsTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    /** Toolbar actions template */
    readonly toolbarActionsTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    /** Fields specified by the directive */
    /** Indicates is multiselect mod enabled */
    readonly isMultiSelect: WritableSignal<boolean>;
    /** Indicates is 'Select All' selector shown */
    readonly isSelectAllSelectorShown: WritableSignal<boolean>;
    /** Indicates is 'Select All' selector disabled */
    readonly isSelectAllSelectorDisabled: WritableSignal<boolean>;
    /** Indicates is all entities selected */
    readonly isAllEntitiesSelected: WritableSignal<boolean>;
    /** Indicates is all entities indeterminate */
    readonly isAllEntitiesIndeterminate: WritableSignal<boolean>;
    /** Current selected entities count */
    readonly selectedEntitiesCount: WritableSignal<number>;
    /** Control for search */
    readonly searchControl: FormControl<Nullable<string>>;
    ngOnInit(): void;
    /** Page model change output action */
    onPageModelChange(pageModel: Partial<PageModel>): void;
    /** Clear search control and search change output action */
    onClearSearch(): void;
    /** Refresh output action */
    onRefresh(): void;
    /** Clear filters output action */
    onClearFilters(): void;
    /** Open table config aside */
    onOpenConfigAside(): void;
    /** Empty method, set in selectors directive */
    onToggleAllEntities: (checked: boolean) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiTableContainerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiTableContainerComponent<any>, "rtui-table-container", never, { "appearance": { "alias": "appearance"; "required": true; "isSignal": true; }; "tableConfigStorageKey": { "alias": "tableConfigStorageKey"; "required": true; "isSignal": true; }; "pageModel": { "alias": "pageModel"; "required": true; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": true; "isSignal": true; }; "fetching": { "alias": "fetching"; "required": true; "isSignal": true; }; "isPlaceholderShown": { "alias": "isPlaceholderShown"; "required": true; "isSignal": true; }; "isPaginationShown": { "alias": "isPaginationShown"; "required": false; "isSignal": true; }; "isRefreshButtonShown": { "alias": "isRefreshButtonShown"; "required": false; "isSignal": true; }; "isTableConfigButtonShown": { "alias": "isTableConfigButtonShown"; "required": false; "isSignal": true; }; "isToolbarActionsIconsOutlined": { "alias": "isToolbarActionsIconsOutlined"; "required": false; "isSignal": true; }; "isFiltersShown": { "alias": "isFiltersShown"; "required": false; "isSignal": true; }; "isFiltersEmpty": { "alias": "isFiltersEmpty"; "required": false; "isSignal": true; }; "searchTerm": { "alias": "searchTerm"; "required": false; "isSignal": true; }; "placeholderIcon": { "alias": "placeholderIcon"; "required": false; "isSignal": true; }; "placeholderTitle": { "alias": "placeholderTitle"; "required": false; "isSignal": true; }; }, { "pageModelChange": "pageModelChange"; "searchChange": "searchChange"; "refreshAction": "refreshAction"; "clearFiltersAction": "clearFiltersAction"; }, ["toolbarSelectorsTpl", "toolbarActionsTpl"], ["*"], true, never>;
}

/** Directive for selectors of the toolbar located on the left side */
declare class RtuiDynamicListToolbarSelectorsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicListToolbarSelectorsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicListToolbarSelectorsDirective, "[rtuiDynamicListToolbarSelectorsDirective]", never, {}, {}, never, never, true, never>;
}
/** Directive for actions of the toolbar located on the right side */
declare class RtuiDynamicListToolbarActionsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicListToolbarActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicListToolbarActionsDirective, "[rtuiDynamicListToolbarActionsDirective]", never, {}, {}, never, never, true, never>;
}
/** Directive for custom table cells */
declare class RtuiDynamicListCustomTableCellsDirective<ENTITY_TYPE> {
    cellsTemplates: InputSignal<{
        [K in keyof ENTITY_TYPE]: TemplateRef<{
            $implicit: ENTITY_TYPE;
        }>;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicListCustomTableCellsDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicListCustomTableCellsDirective<any>, "[rtuiDynamicListCustomTableCellsDirective]", never, { "cellsTemplates": { "alias": "rtuiDynamicListCustomTableCellsDirective"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
/** Directive for row actions located inside a row menu button */
declare class RtuiDynamicListRowActionsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicListRowActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicListRowActionsDirective, "[rtuiDynamicListRowActionsDirective]", never, {}, {}, never, never, true, never>;
}
/** Directive for row actions located outside a row menu button */
declare class RtuiDynamicListRowAdditionalActionsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicListRowAdditionalActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicListRowAdditionalActionsDirective, "[rtuiDynamicListRowAdditionalActionsDirective]", never, {}, {}, never, never, true, never>;
}
declare class RtuiDynamicListComponent<ENTITY_TYPE extends Record<string, unknown>, SORT_PROPERTY extends Extract<keyof ENTITY_TYPE, string>, KEY extends Extract<keyof ENTITY_TYPE, string>> {
    /** Table config storage key */
    tableConfigStorageKey: InputSignalWithTransform<string, unknown>;
    /** Indicates is mobile view */
    isMobile: InputSignalWithTransform<Nullable<boolean>, BooleanInput>;
    /** Indicates is loading in progress */
    loading: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is fetching in progress */
    fetching: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates are table rows clickable */
    isTableRowsClickable: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is pagination shown */
    isPaginationShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is the refresh button shown */
    isRefreshButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is a table config button shown */
    isTableConfigButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is toolbar buttons outlined */
    isToolbarActionsIconsOutlined: InputSignalWithTransform<boolean, BooleanInput>;
    /** Key of ENTITY_TYPE for compare entities */
    keyExp: InputSignal<NonNullable<KEY>>;
    /** List of entities */
    entities: InputSignalWithTransform<ENTITY_TYPE[], ENTITY_TYPE[]>;
    /** Current page model from store */
    pageModel: InputSignal<PageModel>;
    /** Current search term from store */
    searchTerm: InputSignal<Nullable<string>>;
    /** Current sort model from store */
    currentSortModel: InputSignal<Nullable<SortModel<NonNullable<KEY>>>>;
    /** Inputs appearance */
    appearance: InputSignal<MatFormFieldAppearance>;
    /** Filter inputs appearance */
    filterAppearance: InputSignal<MatFormFieldAppearance>;
    /** Current filter model from store */
    filterModel: InputSignalWithTransform<FilterModel<KEY>[], FilterModel<KEY>[]>;
    /** Indicates is filters shown */
    isFiltersShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Sort model change output action */
    readonly sortChange: OutputEmitterRef<SortModel<NonNullable<KEY>>>;
    /** Page model change output action */
    readonly pageModelChange: OutputEmitterRef<Partial<PageModel>>;
    /** Search change output action */
    readonly searchChange: OutputEmitterRef<Nullable<string>>;
    /** Refresh output action */
    readonly refresh: OutputEmitterRef<void>;
    /** Clear filters output action */
    readonly clearFiltersAction: OutputEmitterRef<void>;
    /** Row click output action */
    readonly rowClick: OutputEmitterRef<NonNullable<{
        row: ENTITY_TYPE;
        event: MouseEvent;
    }>>;
    /** Row doubleClick output action */
    readonly rowDoubleClick: OutputEmitterRef<NonNullable<ENTITY_TYPE>>;
    /** Filter change output action */
    readonly filterChange: OutputEmitterRef<FilterModel<KEY>[]>;
    /** Toolbar selectors template */
    readonly toolbarSelectorsTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    /** Toolbar actions template */
    readonly toolbarActionsTpl: Signal<Nullable<TemplateRef<Type<unknown>>>>;
    /** Custom cells template */
    readonly customCellsTpl: Signal<Nullable<RtuiDynamicListCustomTableCellsDirective<{
        $implicit: ENTITY_TYPE;
    }>>>;
    /** Row actions template */
    readonly rowActionsTpl: Signal<Nullable<TemplateRef<{
        $implicit: ENTITY_TYPE;
    }>>>;
    /** Additional row actions template */
    readonly additionalRowActionsTpl: Signal<Nullable<TemplateRef<{
        $implicit: ENTITY_TYPE;
    }>>>;
    /** Table container for selectors directive usage */
    readonly tableContainerTpl: Signal<Nullable<RtuiTableContainerComponent<ENTITY_TYPE>>>;
    /** Table selector for selectors directive usage */
    readonly tableTpl: Signal<Nullable<RtuiTableComponent<ENTITY_TYPE, SORT_PROPERTY, KEY>>>;
    /** Search change output action */
    onSearchChange(value: Nullable<string>): void;
    /** Sort change output action */
    onSortChange(sortModel: SortModel<NonNullable<KEY>>): void;
    /** Page model change output action */
    onPageModelChange(pageModel: Partial<PageModel>): void;
    /** Filter change output action */
    onFilterChange(filterModel: FilterModel<KEY>[]): void;
    /** Refresh output action */
    onRefresh(): void;
    /** Clear filters output action */
    onClearFilters(): void;
    /** Row click output action */
    onRowClick({ row, event }: {
        row: ENTITY_TYPE;
        event: MouseEvent;
    }): void;
    /** Row doubleClick output action */
    onRowDoubleClick(row: ENTITY_TYPE): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicListComponent<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiDynamicListComponent<any, any, any>, "rtui-dynamic-list", never, { "tableConfigStorageKey": { "alias": "tableConfigStorageKey"; "required": true; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fetching": { "alias": "fetching"; "required": false; "isSignal": true; }; "isTableRowsClickable": { "alias": "isTableRowsClickable"; "required": false; "isSignal": true; }; "isPaginationShown": { "alias": "isPaginationShown"; "required": false; "isSignal": true; }; "isRefreshButtonShown": { "alias": "isRefreshButtonShown"; "required": false; "isSignal": true; }; "isTableConfigButtonShown": { "alias": "isTableConfigButtonShown"; "required": false; "isSignal": true; }; "isToolbarActionsIconsOutlined": { "alias": "isToolbarActionsIconsOutlined"; "required": false; "isSignal": true; }; "keyExp": { "alias": "keyExp"; "required": false; "isSignal": true; }; "entities": { "alias": "entities"; "required": true; "isSignal": true; }; "pageModel": { "alias": "pageModel"; "required": true; "isSignal": true; }; "searchTerm": { "alias": "searchTerm"; "required": true; "isSignal": true; }; "currentSortModel": { "alias": "currentSortModel"; "required": true; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": true; "isSignal": true; }; "filterAppearance": { "alias": "filterAppearance"; "required": false; "isSignal": true; }; "filterModel": { "alias": "filterModel"; "required": false; "isSignal": true; }; "isFiltersShown": { "alias": "isFiltersShown"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "pageModelChange": "pageModelChange"; "searchChange": "searchChange"; "refresh": "refresh"; "clearFiltersAction": "clearFiltersAction"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "filterChange": "filterChange"; }, ["toolbarSelectorsTpl", "toolbarActionsTpl", "customCellsTpl", "rowActionsTpl", "additionalRowActionsTpl"], never, true, never>;
}

declare class RtuiStopTableRowClickDirective implements OnInit {
    #private;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiStopTableRowClickDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiStopTableRowClickDirective, "[rtStopTableRowClick]", never, {}, {}, never, never, true, never>;
}

declare class RtuiTableRowClickDirective<ENTITY_TYPE extends Record<string, unknown>, SORT_PROPERTY extends Extract<keyof ENTITY_TYPE, string>, KEY extends Extract<keyof ENTITY_TYPE, string>> {
    #private;
    /** Row entity */
    readonly entity: InputSignal<ENTITY_TYPE>;
    /** Enabled flag */
    isTableRowClickable: InputSignalWithTransform<boolean, BooleanInput>;
    onMouseDown(event: MouseEvent): void;
    onDoubleClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiTableRowClickDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiTableRowClickDirective<any, any, any>, "[rtuiTableRowClickDirective]", never, { "entity": { "alias": "rtuiTableRowClickDirective"; "required": true; "isSignal": true; }; "isTableRowClickable": { "alias": "isTableRowClickable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Returns a set of the necessary dependency injection providers for managing the UI.
 *
 * ```typescript
 * bootstrapApplication(RootComponent, {
 *   providers: [
 *     provideRtUi()
 *   ]
 * });
 * ```
 *
 * @publicApi
 */
declare function provideRtUi(): Provider[];

declare namespace IRtSnackBar {
    interface Config extends MatSnackBarConfig {
        icon?: Nullable<string>;
        isColoredBackground?: boolean;
        action?: Nullable<string>;
        isProgressBarShown?: boolean;
    }
    interface Data extends Config {
        message: string;
    }
}

declare class RtuiSnackBarComponent {
    #private;
    readonly data: IRtSnackBar.Data;
    player: AnimationPlayer | undefined;
    readonly progressTplRef: Signal<Nullable<ElementRef<HTMLElement>>>;
    constructor();
    onMouseOver(): void;
    onMouseOut(): void;
    dismiss(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiSnackBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiSnackBarComponent, "rtui-snack-bar", never, {}, {}, never, never, true, never>;
}

declare class RtSnackBarService {
    #private;
    private readonly defaultConfig;
    default(message: string, config?: IRtSnackBar.Config): MatSnackBarRef<RtuiSnackBarComponent>;
    warning(message: string, config?: IRtSnackBar.Config): MatSnackBarRef<RtuiSnackBarComponent>;
    danger(message: string, config?: IRtSnackBar.Config): MatSnackBarRef<RtuiSnackBarComponent>;
    success(message: string, config?: IRtSnackBar.Config): MatSnackBarRef<RtuiSnackBarComponent>;
    dismiss(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtSnackBarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RtSnackBarService>;
}

declare const progressIncreaseAnimation: AnimationTriggerMetadata[];
declare const progressDecreaseAnimation: AnimationTriggerMetadata[];

declare enum INFO_BADGE_SIZE_ENUM {
    LARGE = "l",
    MEDIUM = "m",
    SMALL = "s"
}
type IInfoBadgeSizeType = INFO_BADGE_SIZE_ENUM.LARGE | INFO_BADGE_SIZE_ENUM.MEDIUM | INFO_BADGE_SIZE_ENUM.SMALL;

declare function darkenHexColor(hex: string, percent: number): string;
declare function getColorBasedOnBackground(backgroundColor: string): string;

declare enum POSITION_ENUM {
    LEFT = "left",
    RIGHT = "right",
    TOP = "top",
    BOTTOM = "bottom",
    START = "start",
    END = "end",
    CENTER = "center"
}

type IconSideType = POSITION_ENUM.LEFT | POSITION_ENUM.RIGHT;

declare class RtuiInfoBadgeComponent implements AfterContentChecked {
    size: InputSignal<IInfoBadgeSizeType>;
    text: InputSignal<string>;
    glyph: InputSignal<string>;
    iconSide: InputSignal<IconSideType>;
    isFontBold: InputSignal<boolean>;
    isMobile: InputSignalWithTransform<Nullable<boolean>, boolean>;
    isTitleCollapsed: WritableSignal<boolean>;
    readonly contentRef: Signal<ElementRef<HTMLElement> | undefined>;
    get badgeClass(): {
        [key: string]: boolean | string;
    };
    get iconStyles(): {
        [key: string]: string;
    };
    ngAfterContentChecked(): void;
    checkEllipsis(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiInfoBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiInfoBadgeComponent, "rtui-info-badge", never, { "size": { "alias": "size"; "required": true; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; "iconSide": { "alias": "iconSide"; "required": false; "isSignal": true; }; "isFontBold": { "alias": "isFontBold"; "required": false; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare enum INFO_BADGE_TYPE_ENUM {
    SUCCESS = "success",
    INFO = "info",
    WARNING = "warning",
    PRIMARY = "primary",
    DISABLED = "disabled"
}
type InfoBadgeType = INFO_BADGE_TYPE_ENUM.SUCCESS | INFO_BADGE_TYPE_ENUM.INFO | INFO_BADGE_TYPE_ENUM.WARNING | INFO_BADGE_TYPE_ENUM.PRIMARY | INFO_BADGE_TYPE_ENUM.DISABLED;

declare enum TOGGLE_SIZE_TYPE_ENUM {
    SM = "sm",
    MD = "md"
}
type ToggleSizeType = TOGGLE_SIZE_TYPE_ENUM.SM | TOGGLE_SIZE_TYPE_ENUM.MD;

declare class RtuiToggleComponent implements OnInit, ControlValueAccessor {
    #private;
    formControl: FormControl<boolean>;
    label: InputSignal<Nullable<string>>;
    tooltip: InputSignal<string>;
    size: InputSignal<ToggleSizeType>;
    tooltipPosition: InputSignal<TooltipPosition>;
    isDisabled: InputSignalWithTransform<boolean, BooleanInput>;
    tooltipDisabled: InputSignalWithTransform<boolean, BooleanInput>;
    readonly isMobile: Signal<Nullable<boolean>>;
    ngOnInit(): void;
    writeValue(value: boolean): void;
    registerOnChange(fn: () => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiToggleComponent, "rtui-toggle", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RtuiFileUploadComponent {
    isIconOutlined: InputSignal<boolean>;
    readonly uploadFile: OutputEmitterRef<File>;
    readonly isDragOver: WritableSignal<boolean>;
    onDragOver(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    onDrop(event: DragEvent): void;
    onFileSelect(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiFileUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiFileUploadComponent, "rtui-file-upload", never, { "isIconOutlined": { "alias": "isIconOutlined"; "required": false; "isSignal": true; }; }, { "uploadFile": "uploadFile"; }, never, never, true, never>;
}

declare abstract class RtuiDynamicSelectorsDirective {
    /** Indicates if mobile view */
    isMobile: InputSignalWithTransform<Nullable<boolean>, boolean>;
    /** Selections control button title */
    buttonTitle: InputSignalWithTransform<string, string>;
    /** Indicates if only one option can be chosen */
    isSingleSelection: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is selector disabled */
    disabled: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is break string pipe used */
    useNameBreaking: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is title case pipe used */
    useTitleCase: InputSignalWithTransform<boolean, boolean>;
    isPlaceholderIconOutlined: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is delete entity button from the selected list shown */
    isDeleteButtonShown: InputSignalWithTransform<boolean, boolean>;
    /** Indicates is list of items draggable */
    isListDraggable: InputSignalWithTransform<boolean, boolean>;
    /** Placeholder icon */
    placeholderIcon: InputSignalWithTransform<string, string>;
    /** Placeholder description */
    placeholderDescription: InputSignalWithTransform<string, string>;
    /** Material elements appearance */
    appearance: InputSignal<MatFormFieldAppearance>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicSelectorsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicSelectorsDirective, never, never, { "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; "buttonTitle": { "alias": "buttonTitle"; "required": false; "isSignal": true; }; "isSingleSelection": { "alias": "isSingleSelection"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "useNameBreaking": { "alias": "useNameBreaking"; "required": false; "isSignal": true; }; "useTitleCase": { "alias": "useTitleCase"; "required": false; "isSignal": true; }; "isPlaceholderIconOutlined": { "alias": "isPlaceholderIconOutlined"; "required": false; "isSignal": true; }; "isDeleteButtonShown": { "alias": "isDeleteButtonShown"; "required": false; "isSignal": true; }; "isListDraggable": { "alias": "isListDraggable"; "required": false; "isSignal": true; }; "placeholderIcon": { "alias": "placeholderIcon"; "required": false; "isSignal": true; }; "placeholderDescription": { "alias": "placeholderDescription"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface FormModel$1 {
    autocompleteControl: FormControl<Nullable<string>>;
}
/** Directive for row actions located outside a row menu button */
declare class RtuiDynamicSelectorAdditionalControlDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicSelectorAdditionalControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicSelectorAdditionalControlDirective, "[rtuiDynamicSelectorAdditionalControlDirective]", never, {}, {}, never, never, true, never>;
}
declare class RtuiDynamicSelectorComponent<ENTITY extends Record<string, unknown>, KEY extends Extract<keyof ENTITY, string>> extends RtuiDynamicSelectorsDirective implements ControlValueAccessor, Validator, OnInit {
    #private;
    /** Config for overlay selector */
    protected readonly connectedOverlayPositions: ConnectedPosition[];
    form: FormGroup<FormModel$1>;
    /** Target element for overlay selector */
    selectedOverlayTrigger: Nullable<CdkOverlayOrigin>;
    /** A model's field which should be used for http-requests */
    keyExp: InputSignal<KEY>;
    /** A model's field which should be shown in ui */
    displayExp: InputSignal<KEY>;
    /** All entities available entities */
    entities: InputSignalWithTransform<ENTITY[], ENTITY[]>;
    /** Navigation button title for popup actions */
    navigateButtonTitle: InputSignal<string>;
    /** Navigation button link for popup actions */
    navigateLink: InputSignal<string>;
    /** Entity keys that can't be changed */
    readonlyEntitiesKeys: InputSignalWithTransform<ENTITY[KEY][], ENTITY[KEY][]>;
    /** Selected entities */
    chosenEntities: ModelSignal<ENTITY[]>;
    /** Indicates is selection available */
    isSelectionAvailable: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is placeholder shown */
    isPlaceholderShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates that a list of entities is being loading */
    loading: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates that a list of entities is being pending */
    pending: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates that a list of entities is being fetching */
    fetching: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates lazy loading is used */
    isLazyLoad: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates local search is used */
    isLocalSearch: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is change multi select mode toggle shown */
    isMultiToggleShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is Select all button shown */
    isSelectAllButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is Open popup button shown */
    isOpenPopupButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Init search term value */
    searchTerm: InputSignal<string>;
    /** Indicates that an additional control has been changed */
    additionalControlChanged: InputSignal<boolean>;
    /** Output search action */
    readonly searchAction: OutputEmitterRef<string>;
    /** Output scroll action, needed for lazy loading */
    readonly scrollAction: OutputEmitterRef<void>;
    /** Output temporary selection action, needed for store values */
    readonly temporarySelectAction: OutputEmitterRef<ENTITY[]>;
    /** Output reset list to initial value action */
    readonly resetAction: OutputEmitterRef<void>;
    /** Output selection change action */
    readonly selectionChangeAction: OutputEmitterRef<ENTITY[]>;
    /** Current selected entities */
    readonly selectedEntities: Signal<ENTITY[]>;
    /** Indicates is popup selector visible */
    readonly isSelectionControlShown: WritableSignal<boolean>;
    /** Indicates is no data */
    readonly isNoDataPlaceholderShown: Signal<boolean>;
    /** Indicates reset selected button is disabled */
    readonly isResetButtonDisabled: Signal<boolean>;
    /** Indicates clear selected button is disabled */
    readonly isClearButtonDisabled: Signal<boolean>;
    /** Entities can be chosen, except selected on init */
    readonly entitiesToSelect: Signal<ENTITY[]>;
    /** Additional control for entity */
    readonly additionalControlTpl: Signal<Nullable<TemplateRef<{
        $implicit: ENTITY;
    }>>>;
    ngOnInit(): void;
    writeValue(value: Array<ENTITY[KEY]>): void;
    registerOnChange(fn: (value: Array<ENTITY[KEY]>) => void): void;
    registerOnTouched(fn: () => void): void;
    validate(): ValidationErrors | null;
    registerOnValidatorChange(fn: () => void): void;
    /** Show popup selector */
    showSelectionControl(trigger: CdkOverlayOrigin): void;
    /** Hide popup selector */
    hideSelectionControl(): void;
    /** Add entity to or delete entity from list of selected */
    toggleEntity(keyValue: ENTITY[KEY]): void;
    /** Clear list of selected entities ids */
    clearList(): void;
    /** Reset list of selected entities ids to init value */
    resetList(): void;
    /** Proceed selected entities ids */
    select(values: ENTITY[KEY][]): void;
    /** Scroll action, needed for lazy load mode */
    scroll(): void;
    /** Search action */
    search(searchTerm: string): void;
    /** Set temporary selection, needed for lazy load mode */
    setTemporarySelection(values: ENTITY[]): void;
    /** Proceed move items in list */
    onDrop(event: CdkDragDrop<ENTITY[]>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicSelectorComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiDynamicSelectorComponent<any, any>, "rtui-dynamic-selector", never, { "keyExp": { "alias": "keyExp"; "required": true; "isSignal": true; }; "displayExp": { "alias": "displayExp"; "required": true; "isSignal": true; }; "entities": { "alias": "entities"; "required": true; "isSignal": true; }; "navigateButtonTitle": { "alias": "navigateButtonTitle"; "required": false; "isSignal": true; }; "navigateLink": { "alias": "navigateLink"; "required": false; "isSignal": true; }; "readonlyEntitiesKeys": { "alias": "readonlyEntitiesKeys"; "required": false; "isSignal": true; }; "chosenEntities": { "alias": "chosenEntities"; "required": false; "isSignal": true; }; "isSelectionAvailable": { "alias": "isSelectionAvailable"; "required": false; "isSignal": true; }; "isPlaceholderShown": { "alias": "isPlaceholderShown"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "fetching": { "alias": "fetching"; "required": false; "isSignal": true; }; "isLazyLoad": { "alias": "isLazyLoad"; "required": false; "isSignal": true; }; "isLocalSearch": { "alias": "isLocalSearch"; "required": false; "isSignal": true; }; "isMultiToggleShown": { "alias": "isMultiToggleShown"; "required": false; "isSignal": true; }; "isSelectAllButtonShown": { "alias": "isSelectAllButtonShown"; "required": false; "isSignal": true; }; "isOpenPopupButtonShown": { "alias": "isOpenPopupButtonShown"; "required": false; "isSignal": true; }; "searchTerm": { "alias": "searchTerm"; "required": false; "isSignal": true; }; "additionalControlChanged": { "alias": "additionalControlChanged"; "required": false; "isSignal": true; }; }, { "chosenEntities": "chosenEntitiesChange"; "searchAction": "searchAction"; "scrollAction": "scrollAction"; "temporarySelectAction": "temporarySelectAction"; "resetAction": "resetAction"; "selectionChangeAction": "selectionChangeAction"; }, ["additionalControlTpl"], never, true, never>;
}

interface FormModel {
    control: FormControl<string[]>;
    controlForUi: FormControl<Nullable<string>>;
}
/** Directive for row actions located outside a row menu button */
declare class RtuiDynamicInputAdditionalControlDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicInputAdditionalControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicInputAdditionalControlDirective, "[rtuiDynamicInputAdditionalControlDirective]", never, {}, {}, never, never, true, never>;
}
declare class RtuiDynamicInputComponent extends RtuiDynamicSelectorsDirective implements ControlValueAccessor, Validator, OnInit {
    #private;
    form: FormGroup<FormModel>;
    /** Indicates is placeholder shown */
    isPlaceholderShown: ModelSignal<Nullable<boolean>>;
    /** Indicates is inputs-editable */
    isInputsEditable: InputSignalWithTransform<boolean, BooleanInput>;
    /** Input label */
    inputLabel: InputSignalWithTransform<string, unknown>;
    /** Input placeholder */
    inputPlaceholder: InputSignalWithTransform<string, unknown>;
    /** Entity keys that can't be changed */
    readonlyEntitiesKeys: InputSignalWithTransform<string[], string[]>;
    /** Array of selected entities */
    readonly selectedEntities: WritableSignal<Array<{
        id: string;
    }>>;
    /** Indicates is input control shown */
    readonly isInputControlShown: WritableSignal<boolean>;
    /** Indicates the reset changes button is disabled */
    readonly isResetButtonDisabled: WritableSignal<boolean>;
    /** Additional control for entity */
    readonly additionalControlTpl: Signal<Nullable<TemplateRef<{
        $implicit: string;
    }>>>;
    ngOnInit(): void;
    writeValue(value: string[]): void;
    registerOnChange(fn: (value: string[]) => void): void;
    registerOnTouched(fn: () => void): void;
    validate(): ValidationErrors | null;
    registerOnValidatorChange(fn: () => void): void;
    /** Hide placeholder */
    hidePlaceholder(): void;
    /** Show control */
    showSelectionControl(): void;
    /** Hide control */
    hideSelectionControl(): void;
    /** Clear list of selected entities ids */
    clearList(): void;
    /** Reset a list of selected entities ids to init value */
    resetList(): void;
    /** Add or delete entity */
    toggleEntity(keyValue: string): void;
    /** Change entity value */
    changeEntity(data: {
        prev: string;
        new: string;
    }): void;
    /** Add new item */
    onAddEntity(): void;
    /** Process move items in a list */
    onDrop(event: CdkDragDrop<Array<{
        id: string;
    }>>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiDynamicInputComponent, "rtui-dynamic-input", never, { "isPlaceholderShown": { "alias": "isPlaceholderShown"; "required": false; "isSignal": true; }; "isInputsEditable": { "alias": "isInputsEditable"; "required": false; "isSignal": true; }; "inputLabel": { "alias": "inputLabel"; "required": false; "isSignal": true; }; "inputPlaceholder": { "alias": "inputPlaceholder"; "required": false; "isSignal": true; }; "readonlyEntitiesKeys": { "alias": "readonlyEntitiesKeys"; "required": false; "isSignal": true; }; }, { "isPlaceholderShown": "isPlaceholderShownChange"; }, ["additionalControlTpl"], never, true, never>;
}

declare class RtuiMultiSelectorPopupComponent<ENTITY extends Record<string, unknown>, KEY extends Extract<keyof ENTITY, string>> implements OnInit, AfterViewInit {
    #private;
    protected readonly oSTypes: typeof OSTypes;
    /** Indicates is mobile view */
    isMobile: InputSignalWithTransform<Nullable<boolean>, Nullable<boolean>>;
    entitiesToSelect: InputSignalWithTransform<ENTITY[], ENTITY[]>;
    /** Material elements appearance */
    appearance: InputSignal<MatFormFieldAppearance>;
    /** A model's field which should be used for http-requests */
    keyExp: InputSignal<KEY>;
    /** A model's field which should be shown in ui */
    displayExp: InputSignal<KEY>;
    /** Init search term value */
    searchTerm: InputSignal<string>;
    /** Navigation button title */
    navigateButtonTitle: InputSignal<string>;
    /** Navigation button link */
    navigateLink: InputSignal<string>;
    /** Indicates if only one option can be chosen */
    isSingleSelection: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is change multi select mode toggle shown */
    isMultiToggleShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is Select all button shown */
    isSelectAllButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates that a list of entities is being loading */
    loading: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates that a list of entities is being fetching */
    fetching: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is BreakStringPipe used */
    useNameBreaking: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates lazy loading is used */
    isLazyLoad: InputSignalWithTransform<Nullable<boolean>, boolean>;
    /** Indicates local search is used */
    isLocalSearch: InputSignalWithTransform<Nullable<boolean>, boolean>;
    /** Send output selected entities ids */
    readonly submitAction: OutputEmitterRef<ENTITY[KEY][]>;
    /** Close popup action */
    readonly closeAction: OutputEmitterRef<void>;
    /** Output search action */
    readonly searchAction: OutputEmitterRef<string>;
    /** Output scroll action, needed for lazy loading */
    readonly scrollAction: OutputEmitterRef<void>;
    /** Output temporary selection action, needed for store values */
    readonly temporarySelectAction: OutputEmitterRef<ENTITY[]>;
    /** Search input Ref for set focus on init */
    readonly searchInputRef: Signal<Nullable<ElementRef<HTMLInputElement>>>;
    /** Form control for search */
    readonly searchControl: FormControl<Nullable<string>>;
    /** Form control for select */
    readonly selectionControl: FormControl<ENTITY[KEY][]>;
    /** Entities filtered by local search */
    readonly filteredEntities: WritableSignal<ENTITY[]>;
    /** Selected entities */
    readonly selectedEntities: WritableSignal<ENTITY[]>;
    /** Indicates is all available entities has been selected */
    readonly isAllSelected: WritableSignal<boolean>;
    /** Indicates is multi selection mode enabled */
    readonly isMultiSelection: WritableSignal<boolean>;
    /** Indicates is macOS used */
    readonly isMacOS: Signal<boolean>;
    ngOnInit(): void;
    /** Set focus on search input  */
    ngAfterViewInit(): void;
    /** Change Multi election mode  */
    toggleMultiSelection(): void;
    /** Toggle select all */
    toggleSelectAll(value: boolean): void;
    /** Update selectionControl and isAllSelected checkbox state */
    itemToggle(entity: ENTITY, checked: boolean): void;
    /** Proceed select action in multi selection mode  */
    onToggleItem(event: MouseEvent, entity: ENTITY, checked: boolean): void;
    /** Proceed select action in single selection mode  */
    onToggleSingleItem(entity: ENTITY, checked: boolean): void;
    /** Output action, selected entities ids */
    onSubmit(): void;
    /** Close popup */
    onClose(): void;
    /** Clear search */
    onClearSearch(): void;
    /** Scroll action, needed for lazy loading mode */
    scroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiMultiSelectorPopupComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiMultiSelectorPopupComponent<any, any>, "rtui-multi-selector-popup", never, { "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; "entitiesToSelect": { "alias": "entitiesToSelect"; "required": true; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": true; "isSignal": true; }; "keyExp": { "alias": "keyExp"; "required": true; "isSignal": true; }; "displayExp": { "alias": "displayExp"; "required": true; "isSignal": true; }; "searchTerm": { "alias": "searchTerm"; "required": false; "isSignal": true; }; "navigateButtonTitle": { "alias": "navigateButtonTitle"; "required": false; "isSignal": true; }; "navigateLink": { "alias": "navigateLink"; "required": false; "isSignal": true; }; "isSingleSelection": { "alias": "isSingleSelection"; "required": false; "isSignal": true; }; "isMultiToggleShown": { "alias": "isMultiToggleShown"; "required": false; "isSignal": true; }; "isSelectAllButtonShown": { "alias": "isSelectAllButtonShown"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fetching": { "alias": "fetching"; "required": false; "isSignal": true; }; "useNameBreaking": { "alias": "useNameBreaking"; "required": false; "isSignal": true; }; "isLazyLoad": { "alias": "isLazyLoad"; "required": false; "isSignal": true; }; "isLocalSearch": { "alias": "isLocalSearch"; "required": false; "isSignal": true; }; }, { "submitAction": "submitAction"; "closeAction": "closeAction"; "searchAction": "searchAction"; "scrollAction": "scrollAction"; "temporarySelectAction": "temporarySelectAction"; }, never, never, true, never>;
}

declare class RtuiDynamicSelectorPlaceholderComponent {
    icon: InputSignalWithTransform<string, string>;
    description: InputSignalWithTransform<string, string>;
    buttonTitle: InputSignalWithTransform<string, string>;
    isButtonShow: InputSignalWithTransform<boolean, boolean>;
    disabled: InputSignalWithTransform<boolean, boolean>;
    isIconOutlined: InputSignalWithTransform<boolean, boolean>;
    readonly submitAction: OutputEmitterRef<CdkOverlayOrigin>;
    onSubmit(trigger: CdkOverlayOrigin): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicSelectorPlaceholderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiDynamicSelectorPlaceholderComponent, "rtui-dynamic-selector-placeholder", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "buttonTitle": { "alias": "buttonTitle"; "required": false; "isSignal": true; }; "isButtonShow": { "alias": "isButtonShow"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "isIconOutlined": { "alias": "isIconOutlined"; "required": false; "isSignal": true; }; }, { "submitAction": "submitAction"; }, never, never, true, never>;
}

declare class RtuiDynamicSelectorListActionsComponent {
    isMobile: InputSignalWithTransform<Nullable<boolean>, Nullable<boolean>>;
    isResetButtonDisabled: InputSignalWithTransform<boolean, boolean>;
    isClearButtonDisabled: InputSignalWithTransform<boolean, boolean>;
    disabled: InputSignalWithTransform<boolean, boolean>;
    readonly resetAction: OutputEmitterRef<void>;
    readonly clearAction: OutputEmitterRef<void>;
    onReset(): void;
    onClear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicSelectorListActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiDynamicSelectorListActionsComponent, "rtui-dynamic-selector-list-actions", never, { "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; "isResetButtonDisabled": { "alias": "isResetButtonDisabled"; "required": true; "isSignal": true; }; "isClearButtonDisabled": { "alias": "isClearButtonDisabled"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "resetAction": "resetAction"; "clearAction": "clearAction"; }, never, never, true, never>;
}

/** Directive for row actions located outside a row menu button */
declare class RtuiDynamicSelectorItemAdditionalControlDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicSelectorItemAdditionalControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtuiDynamicSelectorItemAdditionalControlDirective, "[rtuiDynamicSelectorItemAdditionalControlDirective]", never, {}, {}, never, never, true, never>;
}
declare class RtuiDynamicSelectorSelectedListComponent<ENTITY extends Record<string, unknown>, KEY extends Extract<keyof ENTITY, string>> {
    protected readonly editedItemIndex: WritableSignal<Nullable<number>>;
    readonly inputRef: Signal<Nullable<MatInput>>;
    /** Indicates if mobile view */
    isMobile: InputSignalWithTransform<boolean, BooleanInput>;
    /** A model's field, which should be used for http-requests */
    keyExp: InputSignal<KEY>;
    /** A model's field, which should be shown in ui */
    displayExp: InputSignal<KEY>;
    /** Array of selected entities */
    selectedEntities: InputSignalWithTransform<ENTITY[], ENTITY[]>;
    /** Entity keys that can't be changed */
    readonlyEntitiesKeys: InputSignalWithTransform<ENTITY[KEY][], ENTITY[KEY][]>;
    /** Indicates is a list of items draggable */
    isListDraggable: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is break string pipe used */
    useNameBreaking: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is title case pipe used */
    useTitleCase: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is deleting entity button from the selected list shown */
    isDeleteButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    /** Indicates is items editable */
    isItemsEditable: InputSignalWithTransform<boolean, BooleanInput>;
    /** Material elements appearance */
    appearance: InputSignal<MatFormFieldAppearance>;
    readonly deleteFromSelectedAction: OutputEmitterRef<ENTITY[KEY]>;
    readonly dropAction: OutputEmitterRef<CdkDragDrop<ENTITY[]>>;
    readonly changeValueAction: OutputEmitterRef<{
        prev: ENTITY[KEY];
        new: string;
    }>;
    /** Additional control for entity */
    readonly additionalControlTpl: Signal<Nullable<TemplateRef<{
        $implicit: ENTITY;
    }>>>;
    protected onDelete(value: ENTITY[KEY]): void;
    protected onDrop(event: CdkDragDrop<ENTITY[]>): void;
    protected changeValue(prev: ENTITY[KEY]): void;
    protected setEditModState(index: Nullable<number>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiDynamicSelectorSelectedListComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiDynamicSelectorSelectedListComponent<any, any>, "rtui-dynamic-selector-selected-list", never, { "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; "keyExp": { "alias": "keyExp"; "required": true; "isSignal": true; }; "displayExp": { "alias": "displayExp"; "required": true; "isSignal": true; }; "selectedEntities": { "alias": "selectedEntities"; "required": true; "isSignal": true; }; "readonlyEntitiesKeys": { "alias": "readonlyEntitiesKeys"; "required": false; "isSignal": true; }; "isListDraggable": { "alias": "isListDraggable"; "required": false; "isSignal": true; }; "useNameBreaking": { "alias": "useNameBreaking"; "required": false; "isSignal": true; }; "useTitleCase": { "alias": "useTitleCase"; "required": false; "isSignal": true; }; "isDeleteButtonShown": { "alias": "isDeleteButtonShown"; "required": false; "isSignal": true; }; "isItemsEditable": { "alias": "isItemsEditable"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, { "deleteFromSelectedAction": "deleteFromSelectedAction"; "dropAction": "dropAction"; "changeValueAction": "changeValueAction"; }, ["additionalControlTpl"], never, true, never>;
}

type IImageUploadFormat = 'png' | 'jpeg' | 'webp';
declare class RtuiImageUploadComponent {
    #private;
    protected readonly imageFormat: Signal<IImageUploadFormat>;
    imageUrl: ModelSignal<Nullable<string>>;
    isMobile: InputSignalWithTransform<boolean, boolean>;
    fileName: InputSignalWithTransform<string, string>;
    isActive: InputSignalWithTransform<boolean, BooleanInput>;
    isSaveButtonShown: InputSignalWithTransform<boolean, BooleanInput>;
    isDownloadButtonEnabled: InputSignalWithTransform<boolean, BooleanInput>;
    isTooltipDisabled: InputSignalWithTransform<boolean, BooleanInput>;
    isActionsShown: InputSignalWithTransform<boolean, BooleanInput>;
    loading: InputSignalWithTransform<boolean, BooleanInput>;
    tooltip: InputSignal<string>;
    tooltipPosition: InputSignal<TooltipPosition>;
    imageQuality: InputSignal<number>;
    originalImage: WritableSignal<File | undefined>;
    croppedImage: WritableSignal<Nullable<File>>;
    tempImage: WritableSignal<Nullable<string>>;
    readonly imageChanged: OutputEmitterRef<File>;
    readonly save: OutputEmitterRef<void>;
    onFileSelect(event: Event): void;
    onImageCropped(event: ImageCroppedEvent): void;
    onFileUpload(file: File): void;
    onApply(): void;
    onCancel(): void;
    onDownloadImage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiImageUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiImageUploadComponent, "rtui-image-upload", never, { "imageUrl": { "alias": "imageUrl"; "required": true; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isSaveButtonShown": { "alias": "isSaveButtonShown"; "required": false; "isSignal": true; }; "isDownloadButtonEnabled": { "alias": "isDownloadButtonEnabled"; "required": false; "isSignal": true; }; "isTooltipDisabled": { "alias": "isTooltipDisabled"; "required": false; "isSignal": true; }; "isActionsShown": { "alias": "isActionsShown"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "imageQuality": { "alias": "imageQuality"; "required": false; "isSignal": true; }; }, { "imageUrl": "imageUrlChange"; "imageChanged": "imageChanged"; "save": "save"; }, never, never, true, never>;
}

type MenuItemTrigger = 'click' | 'hover';
declare class RtPopoverDirective implements OnInit, OnDestroy {
    #private;
    xOffset: InputSignalWithTransform<number, NumberInput>;
    yOffset: InputSignalWithTransform<number, NumberInput>;
    trigger: InputSignalWithTransform<MenuItemTrigger, MenuItemTrigger>;
    template: InputSignalWithTransform<Nullable<TemplateRef<HTMLElement>>, Nullable<TemplateRef<HTMLElement>>>;
    isMouseHoverAllowed: InputSignalWithTransform<boolean, BooleanInput>;
    onClick(element: EventTarget | null): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtPopoverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RtPopoverDirective, "[rtPopover]", never, { "xOffset": { "alias": "xOffset"; "required": false; "isSignal": true; }; "yOffset": { "alias": "yOffset"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; "isMouseHoverAllowed": { "alias": "isMouseHoverAllowed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare namespace IRtActionBar {
    interface Config {
        selected?: number;
        total?: number;
        buttons?: IRtActionBar.Button[];
    }
    interface Button {
        title: string;
        action?: (payload?: object) => void;
        icon?: string;
        menu?: IRtActionBar.Button[];
        styles?: object;
    }
}

declare class RtuiActionBarComponent {
    #private;
    config: InputSignal<IRtActionBar.Config>;
    readonly closeAction: OutputEmitterRef<void>;
    readonly isTablet: Signal<boolean>;
    onClose(): void;
    onAction(button: IRtActionBar.Button): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiActionBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiActionBarComponent, "rtui-action-bar", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "closeAction": "closeAction"; }, never, never, true, never>;
}

declare class RtuiActionBarContainerComponent {
    #private;
    readonly config: Signal<IRtActionBar.Config>;
    closeBar(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtuiActionBarContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RtuiActionBarContainerComponent, "rtui-action-bar-container", never, {}, {}, never, never, true, never>;
}

declare class RtActionBarService {
    config: WritableSignal<IRtActionBar.Config>;
    setActions(buttons: IRtActionBar.Button[]): void;
    setCounts(selected: number, total: number): void;
    closeActionBar(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RtActionBarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RtActionBarService>;
}

export { ASIDE_BUTTONS_ENUM, ASIDE_REF, AsideRef, BASE_INITIAL_STATE, BUTTON_APPEARANCE, BUTTON_COLOR, BUTTON_SIZE, BaseAsyncStoreService, BaseMapper, BaseStoreService, BlockDirective, BreakStringPipe, BreakpointService, Breakpoints, CUSTOM_STORAGE, ConcatClassesPipe, DASH, DEFAULT_PAGE_MODEL, DEFAULT_PAGE_SIZE, DeviceDetectorService, ElemDirective, EmptyToDashPipe, EntityToStringPipe, EqualChainPipe, EqualPipe, FILTER_OPERATORS, FILTER_OPERATOR_TYPE_ENUM, HAS_OWN_SCOPE_ENUM, IAside, IDBStorageService, IDB_STORAGE_SERVICE_TOKEN, IModal, INFO_BADGE_SIZE_ENUM, INFO_BADGE_TYPE_ENUM, IN_MEMORY_STORAGE, IRtActionBar, IRtSnackBar, ISideMenu, IStateBase, ITable, InMemoryStorageService, JsonConverter, LIST_SORT_ORDER_ENUM, LOCAL_STORAGE, MODAL_WINDOW_SIZE_ENUM, MessageBus, ModDirective, ModelStatus, NAVIGATOR, NotEqualChainPipe, NotEqualPipe, OSTypes, OVERLAY_POSITIONS, PlatformService, RTUI_TABLE_COMPONENT_TOKEN, RTUI_TABLE_STOP_ROW_CLICK_ATTRIBUTE, RtActionBarService, RtAsideService, RtDynamicListSelectorsDirective, RtEscapeKeyDirective, RtHideTooltipDirective, RtIconOutlinedDirective, RtModalService, RtNavigationDirective, RtPopoverDirective, RtScrollDirective, RtScrollToElementDirective, RtSnackBarService, RtTabQueryParamDirective, RtTableConfigService, RtTableSelectorsDirective, RtuiActionBarComponent, RtuiActionBarContainerComponent, RtuiAsideContainerComponent, RtuiAsideContainerHeaderDirective, RtuiButtonComponent, RtuiClearButtonComponent, RtuiCustomTableCellsDirective, RtuiDynamicInputAdditionalControlDirective, RtuiDynamicInputComponent, RtuiDynamicListComponent, RtuiDynamicListCustomTableCellsDirective, RtuiDynamicListRowActionsDirective, RtuiDynamicListRowAdditionalActionsDirective, RtuiDynamicListToolbarActionsDirective, RtuiDynamicListToolbarSelectorsDirective, RtuiDynamicSelectorAdditionalControlDirective, RtuiDynamicSelectorComponent, RtuiDynamicSelectorItemAdditionalControlDirective, RtuiDynamicSelectorListActionsComponent, RtuiDynamicSelectorPlaceholderComponent, RtuiDynamicSelectorSelectedListComponent, RtuiFileUploadComponent, RtuiHeaderCenterDirective, RtuiHeaderComponent, RtuiHeaderLeftDirective, RtuiHeaderRightDirective, RtuiImageUploadComponent, RtuiInfoBadgeComponent, RtuiModalComponent, RtuiMultiButtonComponent, RtuiMultiSelectorPopupComponent, RtuiPaginationComponent, RtuiRoundIconButtonComponent, RtuiScrollableContainerComponent, RtuiScrollableContainerContentDirective, RtuiScrollableContainerFooterDirective, RtuiScrollableContainerHeaderDirective, RtuiSideMenuComponent, RtuiSideMenuFooterDirective, RtuiSideMenuHeaderDirective, RtuiSnackBarComponent, RtuiSpinnerComponent, RtuiStopTableRowClickDirective, RtuiTableAdditionalRowActionsDirective, RtuiTableComponent, RtuiTableRowActionsDirective, RtuiTableRowClickDirective, RtuiToggleComponent, RtuiToolbarCenterDirective, RtuiToolbarComponent, RtuiToolbarLeftDirective, RtuiToolbarRightDirective, SESSION_STORAGE, STORAGE_TYPES_ENUM, SanitizePipe, StorageService, TABLE_COLUMN_FILTER_TYPES_ENUM, TABLE_COLUMN_TYPES_ENUM, TEXT_CELL_COLOR_ENUM, TOGGLE_SIZE_TYPE_ENUM, TernaryPipe, TypeCastHelper, WINDOW, areArraysEqual, areArraysEqualUnordered, areObjectsEqual, arraysNotEmptyValidator, checkIsEntityInArrayByKey, checkIsMatchingValues, darkenHexColor, dateStringToDate, ddServices, debounce, emptyToDash, formatDate, getColorBasedOnBackground, hasPropertyInChain, iDBStorageFactory, inMemoryStorageFactory, initToday, isDate, isDateValid, isEmail, isEmpty, isEmptyArray, isEmptyObject, isEmptyString, isEqual, isNil, isNumber, isRecord, isString, isToday, localStorageFactory, parseDate, parseISO, progressDecreaseAnimation, progressIncreaseAnimation, provideRtIDBStorage, provideRtStorage, provideRtUi, provideRtUtils, removeFieldFromObject, safeComparatorPipe, safeCompare, safeNumCompare, safeStrCompare, sessionStorageFactory, sortByAlphabet, sortByDate, stringifyHttpLikeParams, transformArrayInput, transformStringInput };
export type { AnyObject, AsideButtonsType, AsidePositions, ButtonAppearanceType, ButtonColorType, ButtonSizeType, ComparatorType, EmptyObject, FilterModel, FilterOperatorType, IAction, IBaseAsyncStoreService, IBaseMapper, IBaseStoreService, IBemConfig, IBreakpoints, IDictionary, IHasScopeType, IIDBStorageServiceInterface, IImageUploadFormat, IInfoBadgeSizeType, IMapper, IModsObject, IRtuiTable, ISetPropertiesConfig, IStorageConfig, IStorageConverter, Icon, IconSideType, InfoBadgeType, IntersectionType, ListSortOrderType, ListState, MenuItemTrigger, MessageBusEvent, ModalWindowSizeType, Modify, NameValueType, Nullable, Optional, PageModel, PartialOmit, Primitive, Scriptable, ScriptableAndArray, ScriptableAndArrayOptions, ScriptableAndScriptableOptions, ScriptableOptions, Select, SortModel, StorageType, ToggleSizeType, ValuesType };