@rt-tools/ui-kit 0.0.4

package/types/rt-tools-ui-kit.d.ts

@@ -0,0 +1,1875 @@
+import * as i0 from '@angular/core';
+import { OnChanges, ElementRef, Renderer2, PipeTransform, Provider, InjectionToken, Type, OnInit, Signal, TemplateRef, WritableSignal, InputSignal, InputSignalWithTransform, OutputEmitterRef, ModelSignal, AfterViewInit, AfterViewChecked, AfterContentChecked, OnDestroy } from '@angular/core';
+import { Nullable, Icon, Select, ISideMenu, AsidePositions, IAside, AsideButtonsType, POSITION_ENUM, OSTypes } from '@rt-tools/utils';
+export * from '@rt-tools/utils';
+export * from '@rt-tools/store';
+import { Observable } from 'rxjs';
+import { FormControl, ControlValueAccessor, Validator, FormGroup, ValidationErrors } from '@angular/forms';
+import { ThemePalette } from '@angular/material/core';
+import { MatDialogConfig } from '@angular/material/dialog';
+import { MatDrawer } from '@angular/material/sidenav';
+import { ComponentType } from '@angular/cdk/portal';
+import { HttpErrorResponse } from '@angular/common/http';
+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 { ConnectedPosition, CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { MatInput } from '@angular/material/input';
+import { ImageCroppedEvent } from 'ngx-image-cropper';
+
+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>;
+}
+
+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>;
+
+/**
+ * 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>>;
+
+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>;
+}
+
+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<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;
+
+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 { BUTTON_APPEARANCE, BUTTON_COLOR, BUTTON_SIZE, BlockDirective, CUSTOM_STORAGE, ConcatClassesPipe, DEFAULT_PAGE_MODEL, DEFAULT_PAGE_SIZE, ElemDirective, FILTER_OPERATORS, FILTER_OPERATOR_TYPE_ENUM, IDBStorageService, IDB_STORAGE_SERVICE_TOKEN, IModal, INFO_BADGE_SIZE_ENUM, INFO_BADGE_TYPE_ENUM, IN_MEMORY_STORAGE, IRtActionBar, IRtSnackBar, ITable, InMemoryStorageService, JsonConverter, LIST_SORT_ORDER_ENUM, LOCAL_STORAGE, ModDirective, RTUI_TABLE_COMPONENT_TOKEN, RTUI_TABLE_STOP_ROW_CLICK_ATTRIBUTE, RtActionBarService, RtAsideService, RtDynamicListSelectorsDirective, RtModalService, RtPopoverDirective, RtSnackBarService, 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, StorageService, TABLE_COLUMN_FILTER_TYPES_ENUM, TABLE_COLUMN_TYPES_ENUM, TEXT_CELL_COLOR_ENUM, TOGGLE_SIZE_TYPE_ENUM, darkenHexColor, getColorBasedOnBackground, iDBStorageFactory, inMemoryStorageFactory, localStorageFactory, progressDecreaseAnimation, progressIncreaseAnimation, provideRtIDBStorage, provideRtStorage, provideRtUi, sessionStorageFactory };
+export type { ButtonAppearanceType, ButtonColorType, ButtonSizeType, FilterModel, FilterOperatorType, IBemConfig, IIDBStorageServiceInterface, IImageUploadFormat, IInfoBadgeSizeType, IModsObject, IRtuiTable, IStorageConfig, IStorageConverter, IconSideType, InfoBadgeType, ListSortOrderType, ListState, MenuItemTrigger, PageModel, SortModel, StorageType, ToggleSizeType };