@rt-tools/utils 0.0.1

package/types/rt-tools-utils.d.ts

@@ -0,0 +1,625 @@
+import { ConnectedPosition, OverlayRef, ComponentType } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { InputSignalWithTransform, InputSignal, AfterViewInit, OnInit, Signal, OnDestroy, OutputEmitterRef, PipeTransform, InjectionToken, Provider } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { Nullable } from '@rt-tools/core';
+export { IDictionary, MessageBus, MessageBusEvent, Nullable, PlatformService, Primitive, WINDOW, isNil } from '@rt-tools/core';
+import { SafeHtml } from '@angular/platform-browser';
+import { Subject } from 'rxjs';
+import { ValidatorFn, AbstractControl, ValidationErrors } from '@angular/forms';
+
+declare const OVERLAY_POSITIONS: Readonly<ConnectedPosition[]>;
+
+declare const DASH: string;
+
+declare class RtIconOutlinedDirective {
+    isOutlined: InputSignalWithTransform<boolean, BooleanInput>;
+    get fontVariationSettings(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtIconOutlinedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RtIconOutlinedDirective, "mat-icon[rtIconOutlined]", never, { "isOutlined": { "alias": "rtIconOutlined"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RtScrollToElementDirective {
+    #private;
+    rtScrollToElement: InputSignal<string | number>;
+    elements: InputSignalWithTransform<unknown[], unknown[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtScrollToElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RtScrollToElementDirective, "[rtScrollToElement]", never, { "rtScrollToElement": { "alias": "rtScrollToElement"; "required": true; "isSignal": true; }; "elements": { "alias": "elements"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RtHideTooltipDirective implements AfterViewInit {
+    #private;
+    /** Current HTMLElement */
+    element: InputSignal<HTMLElement>;
+    /** Indicates is tooltip shown */
+    isTooltipShown: InputSignalWithTransform<boolean, boolean>;
+    /** Set tooltip state by 'isTooltipShown' */
+    constructor();
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtHideTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RtHideTooltipDirective, "[rtHideTooltipDirective]", never, { "element": { "alias": "rtHideTooltipDirective"; "required": true; "isSignal": true; }; "isTooltipShown": { "alias": "isTooltipShown"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AnyObject = Record<string, any>;
+type EmptyObject = Record<string, never>;
+
+type IntersectionType<T extends object, M extends object> = keyof T & keyof M;
+
+type Modify<T, R> = Omit<T, keyof R> & R;
+
+type PartialOmit<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+
+interface IMapper<I, M> {
+    mapFrom(raw: I): M;
+    mapTo?(model: M): I;
+}
+
+/** Makes selected props from a record optional */
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+
+/** Get the union type of all the values in an object, array or array-like type */
+type ValuesType<T extends ReadonlyArray<unknown> | ArrayLike<unknown> | Record<string | number | symbol, unknown>> = T extends ReadonlyArray<unknown> ? T[number] : T extends ArrayLike<unknown> ? T[number] : T extends object ? T[keyof T] : never;
+
+declare class TypeCastHelper {
+    getAsString(data: unknown, defaultValue?: string): string;
+    getAsNumber(data: unknown, defaultValue?: number): number;
+    getAsBoolean(data: unknown): boolean;
+    getAsNull<T = unknown, R = T>(data: T, handler?: (data: T) => R): T | R | null;
+    getAsType(value: unknown, type: NonNullable<unknown>): any;
+    getAsTypedArray<T>(data: unknown[], cb: (item: unknown) => T, showError?: boolean): T[];
+    getAsDate(date: string | number | Date, asString?: boolean, parseFormatOptions?: string, formatOptions?: string): Date | string;
+}
+
+interface IBaseMapper<M> {
+    typeCast: TypeCastHelper;
+    mapTo?: (model: M, ...args: any[]) => any;
+    mapFrom?: (data: any, ...args: any[]) => M;
+    mapToArray?: (models: M[], ...args: any[]) => any;
+    mapFromArray?: (data: any[], ...args: any[]) => M[];
+}
+
+type Scriptable<T, TContext> = T | ((ctx: TContext, options: AnyObject) => T | undefined);
+type ScriptableOptions<T, TContext> = {
+    [P in keyof T]: Scriptable<T[P], TContext>;
+};
+type ScriptableAndScriptableOptions<T, TContext> = Scriptable<T, TContext> | ScriptableOptions<T, TContext>;
+type ScriptableAndArray<T, TContext> = readonly T[] | Scriptable<T, TContext>;
+type ScriptableAndArrayOptions<T, TContext> = {
+    [P in keyof T]: ScriptableAndArray<T[P], TContext>;
+};
+
+interface Icon {
+    value: string;
+    style?: {
+        [className: string]: string;
+    };
+}
+interface Select<T> {
+    value: Array<NameValueType<string, T>>;
+    label?: string;
+    hint?: string;
+}
+interface NameValueType<N = string, V = string> {
+    name: N;
+    value: V;
+}
+
+declare namespace ISideMenu {
+    type ItemData = string | number | object;
+    interface Item {
+        id: string | number;
+        icon?: string;
+        name?: string;
+        link?: string;
+        submenu?: Item[];
+        iconButton?: {
+            icon: string;
+            data?: ItemData;
+        };
+    }
+}
+
+declare enum ASIDE_BUTTONS_ENUM {
+    USER_ACTIVE = "User active",
+    USER_INACTIVE = "User inactive",
+    DELETE = "Delete",
+    RESET = "Reset"
+}
+type AsideButtonsType = ASIDE_BUTTONS_ENUM.USER_ACTIVE | ASIDE_BUTTONS_ENUM.USER_INACTIVE | ASIDE_BUTTONS_ENUM.DELETE | ASIDE_BUTTONS_ENUM.RESET;
+
+declare namespace IAside {
+    interface HeaderActionButton {
+        name: AsideButtonsType;
+        icon: string;
+        color: string;
+        tooltip: string;
+        disabled?: boolean;
+    }
+}
+
+declare class RtNavigationDirective {
+    #private;
+    link: InputSignal<Nullable<string>>;
+    onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtNavigationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RtNavigationDirective, "[rtNavigationDirective]", never, { "link": { "alias": "rtNavigationDirective"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class RtTabQueryParamDirective implements OnInit {
+    #private;
+    readonly currentTabIndex: Signal<number>;
+    ngOnInit(): void;
+    setQueryTab(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtTabQueryParamDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RtTabQueryParamDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class RtScrollDirective implements OnInit, OnDestroy {
+    #private;
+    active: InputSignal<boolean>;
+    multiplier: InputSignal<number>;
+    readonly scrollAction: OutputEmitterRef<void>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    scroll: EventListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RtScrollDirective, "[rtScrollDirective]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "multiplier": { "alias": "multiplier"; "required": false; "isSignal": true; }; }, { "scrollAction": "scrollAction"; }, never, never, true, never>;
+}
+
+declare class RtEscapeKeyDirective {
+    readonly escapeKeyAction: OutputEmitterRef<void>;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtEscapeKeyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RtEscapeKeyDirective, "[rtEscapeKey]", never, {}, { "escapeKeyAction": "escapeKeyAction"; }, never, never, true, never>;
+}
+
+declare enum MODAL_WINDOW_SIZE_ENUM {
+    SM = "25rem",
+    MD = "45rem",
+    LG = "65rem",
+    FULL = "100%"
+}
+type ModalWindowSizeType = MODAL_WINDOW_SIZE_ENUM.SM | MODAL_WINDOW_SIZE_ENUM.MD | MODAL_WINDOW_SIZE_ENUM.LG | MODAL_WINDOW_SIZE_ENUM.FULL;
+
+declare enum POSITION_ENUM {
+    LEFT = "left",
+    RIGHT = "right",
+    TOP = "top",
+    BOTTOM = "bottom",
+    START = "start",
+    END = "end",
+    CENTER = "center"
+}
+
+/**
+ * Date formatting and parsing utilities (replacement for date-fns)
+ *
+ * Supported format tokens:
+ * - yyyy: 4-digit year (2024)
+ * - yy: 2-digit year (24)
+ * - MM: 2-digit month (01-12)
+ * - M: month (1-12)
+ * - dd: 2-digit day (01-31)
+ * - d: day (1-31)
+ * - HH: 2-digit hour 24h (00-23)
+ * - H: hour 24h (0-23)
+ * - hh: 2-digit hour 12h (01-12)
+ * - h: hour 12h (1-12)
+ * - mm: 2-digit minutes (00-59)
+ * - m: minutes (0-59)
+ * - ss: 2-digit seconds (00-59)
+ * - s: seconds (0-59)
+ * - SSS: milliseconds (000-999)
+ * - a: AM/PM
+ * - EEEE: full weekday name (Monday)
+ * - EEE: short weekday name (Mon)
+ * - MMMM: full month name (January)
+ * - MMM: short month name (Jan)
+ */
+/**
+ * Checks if a value is a valid Date object
+ */
+declare function isDate(value: unknown): value is Date;
+/**
+ * Formats a Date object according to the specified format string
+ *
+ * @param date - The date to format
+ * @param formatStr - The format string (e.g., 'dd.MM.yyyy', 'yyyy-MM-dd HH:mm:ss')
+ * @returns Formatted date string
+ *
+ * @example
+ * formatDate(new Date(2024, 0, 15), 'dd.MM.yyyy') // '15.01.2024'
+ * formatDate(new Date(2024, 0, 15, 14, 30), 'yyyy-MM-dd HH:mm') // '2024-01-15 14:30'
+ */
+declare function formatDate(date: Date, formatStr: string): string;
+/**
+ * Parses an ISO 8601 date string into a Date object
+ *
+ * @param dateString - ISO date string (e.g., '2024-01-15', '2024-01-15T14:30:00.000Z')
+ * @returns Date object or Invalid Date if parsing fails
+ *
+ * @example
+ * parseISO('2024-01-15') // Date object for Jan 15, 2024
+ * parseISO('2024-01-15T14:30:00.000Z') // Date object with time
+ */
+declare function parseISO(dateString: string): Date;
+/**
+ * Parses a date string according to the specified format
+ *
+ * @param dateString - The date string to parse
+ * @param formatStr - The format string describing the input
+ * @param referenceDate - Reference date for missing parts (defaults to current date)
+ * @returns Date object or Invalid Date if parsing fails
+ *
+ * @example
+ * parseDate('15.01.2024', 'dd.MM.yyyy') // Date object for Jan 15, 2024
+ * parseDate('2024/01/15 14:30', 'yyyy/MM/dd HH:mm') // Date with time
+ */
+declare function parseDate(dateString: string, formatStr: string, referenceDate?: Date): Date;
+
+declare function dateStringToDate(date: string | Date): Date;
+
+declare function isDateValid(date?: Date): boolean;
+
+/**
+ * Indicates if the arguments are equal
+ *
+ * @param f first parameter to compare
+ * @param s second parameter to compare
+ */
+declare function isEqual<T>(f: T, s: T): boolean;
+/**
+ * Indicates if the content of two arrays is identical
+ *
+ * @param f first array
+ * @param s second array
+ */
+declare function areArraysEqual<T>(f: T[], s: T[]): boolean;
+/**
+ * Indicates if the content of two objects is identical
+ *
+ * @param f first object
+ * @param s second object
+ */
+declare function areObjectsEqual<T>(f: T, s: T): boolean;
+/**
+ * Checks whether two arrays are equal regardless of the order of their elements.
+ * Supports deep comparison of nested arrays and objects.
+ *
+ * @template T The type of elements in the arrays
+ * @param f first array
+ * @param s second array
+ * @returns True if the arrays contain the same elements in any order, false otherwise
+ */
+declare function areArraysEqualUnordered<T>(f: T[], s: T[]): boolean;
+
+declare function isNumber<T>(value: T | number | unknown | undefined): value is number;
+
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+
+declare function isString<T>(value: T | null | undefined | unknown): value is string;
+
+declare function initToday(): Date;
+declare function isToday(date: Date): boolean;
+
+/** Makes shallow copy of passed object */
+declare function removeFieldFromObject<T extends object, K extends string>(obj: T, key: K): Omit<T, K>;
+
+type ComparatorType<T> = (aa: T, bb: T) => number;
+/**
+ * Allow to compare two values by provided comparator
+ *
+ * @param a - T
+ * @param b - T
+ * @param comparator - ComparatorType<T>
+ */
+declare function safeCompare<T>(a: T, b: T, comparator: ComparatorType<T>): number;
+/**
+ * Allow to safely compare two string values
+ *
+ * @param a string
+ * @param b string
+ */
+declare function safeStrCompare(a: string, b: string): number;
+/**
+ * Allow to safely compare two number values
+ *
+ * @param a number
+ * @param b number
+ */
+declare function safeNumCompare(a: number, b: number): number;
+/**
+ * Allow composing comparison chain of several comparators
+ * that delegate comparison by the chain to the next comparators if current comparator returns 0
+ *
+ * @param comparators - Array<() => number>
+ */
+declare function safeComparatorPipe(...comparators: Array<() => number>): number;
+
+declare const sortByAlphabet: <T extends object>(a: T, b: T, field: keyof T) => number;
+declare const sortByDate: (a: {
+    [field: string]: any;
+}, b: {
+    [field: string]: any;
+}, field: string) => number;
+
+declare function stringifyHttpLikeParams<T extends object>(params: T): {
+    [param: string]: string | string[];
+};
+
+declare function transformArrayInput<T>(array: unknown): T[];
+
+declare function transformStringInput(value: unknown): string;
+
+declare function checkIsEntityInArrayByKey<ENTITY extends Record<string, unknown>, KEY extends Extract<keyof ENTITY, string>>(selectedEntities: ENTITY[], entity: ENTITY, keyExp: KEY): boolean;
+
+declare function emptyToDash<T>(value: T | null | undefined): T | string;
+
+/**
+ * Check if the email is valid
+ * @param email
+ */
+declare function isEmail(email: any): boolean;
+
+declare function isEmpty(value: unknown): boolean;
+
+declare function isEmptyString(value: string): boolean;
+
+declare function isEmptyArray<T>(value: T[]): boolean;
+
+declare function isEmptyObject(value: Record<string, unknown>): boolean;
+
+declare function debounce(timeout?: number): MethodDecorator;
+
+declare enum HAS_OWN_SCOPE_ENUM {
+    ANY = "any",
+    OWN = "own",
+    INHERITED = "inherited"
+}
+type IHasScopeType = HAS_OWN_SCOPE_ENUM.ANY | HAS_OWN_SCOPE_ENUM.OWN | HAS_OWN_SCOPE_ENUM.INHERITED;
+/**
+ * Safe property existence check with configurable scope.
+ *
+ * - Returns `false` for `null`/`undefined`.
+ * - Boxes primitives (e.g., strings, numbers) so prototype checks work.
+ * - Does **not** invoke getters; relies on `in` and an own-check helper.
+ * - Uses `Object.hasOwn` when available; **falls back** to
+ *   `Object.prototype.hasOwnProperty.call` on older runtimes.
+ *
+ * @param obj {unknown} - Value to check. `null`/`undefined` short-circuit to `false`.
+ * @param key {PropertyKey} - Property key (string | number | symbol).
+ * @param scope {IHasScopeType} - Check mode: `'any'` (default), `'own'`, or `'inherited'`.
+ *
+ * @returns `true` if the property exists under the selected scope.
+ *
+ * @example
+ * hasPropertyInChain({ a: 1 }, 'a'); // true (ANY)
+ * hasPropertyInChain(Object.create({ a: 1 }), 'a', HAS_OWN_SCOPE_ENUM.INHERITED); // true
+ * hasPropertyInChain({ a: 1 }, 'b', HAS_OWN_SCOPE_ENUM.OWN); // false
+ */
+declare function hasPropertyInChain(obj: unknown, key: PropertyKey, scope?: IHasScopeType): boolean;
+
+declare abstract class BaseMapper<M> implements IBaseMapper<M> {
+    readonly typeCast: TypeCastHelper;
+    mapFrom(data: NonNullable<unknown>, ...args: unknown[]): M;
+    mapFromArray(data: NonNullable<unknown>[], ...args: unknown[]): M[];
+    mapTo(model: M, ...args: unknown[]): unknown;
+    mapToArray(models: M[], ...args: unknown[]): unknown[];
+}
+
+declare class BreakStringPipe implements PipeTransform {
+    transform(value: Nullable<string>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreakStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BreakStringPipe, "breakString", true>;
+}
+
+declare class SanitizePipe implements PipeTransform {
+    #private;
+    transform(value: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizePipe, "sanitize", true>;
+}
+
+declare class EntityToStringPipe implements PipeTransform {
+    transform<T>(value: T): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityToStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EntityToStringPipe, "entityToString", true>;
+}
+
+declare class EmptyToDashPipe implements PipeTransform {
+    transform<T>(value: T | null | undefined): T | string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyToDashPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EmptyToDashPipe, "emptyToDash", true>;
+}
+
+/**
+ * @description Use to compare equality to any of items with provided value
+ * @example
+ *
+ * Direct usage
+ * ```ts
+ *   equalPipe.transform(100, 1, 10, 100) // => true
+ * ```
+ *
+ * Template usage
+ *
+ * ```html
+ *   <div *ngIf="100 | equal:1:10:100">Visible</div>
+ * ```
+ */
+declare class EqualPipe implements PipeTransform {
+    transform(value: any, ...compares: any[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EqualPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EqualPipe, "equal", true>;
+}
+
+/**
+ * @description Use to access to the deep object state for comparison
+ * @example
+ *  {a: {b: true}} | equalChain:'a':'b':true => true
+ */
+declare class EqualChainPipe implements PipeTransform {
+    transform(obj: object, ...args: any[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EqualChainPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EqualChainPipe, "equalChain", true>;
+}
+
+/**
+ * @description Use to compare not equality to all items with provided value
+ * @example
+ *
+ * Direct usage
+ * ```ts
+ *   notEqualPipe.transform(100, 1, 10, 100) // => false
+ * ```
+ *
+ * Template usage
+ *
+ * ```html
+ *   <div *ngIf="100 | notEqual:1:10:100">Invisible</div>
+ * ```
+ */
+declare class NotEqualPipe implements PipeTransform {
+    transform(value: any, ...compares: any[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotEqualPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NotEqualPipe, "notEqual", true>;
+}
+
+/**
+ * @description Use to access to the deep object state for comparison
+ * @example
+ *  {a: {b: true}} | equalChain:'a':'b':false => true
+ */
+declare class NotEqualChainPipe implements PipeTransform {
+    transform(obj: object, ...args: any[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotEqualChainPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NotEqualChainPipe, "notEqualChain", true>;
+}
+
+declare class TernaryPipe implements PipeTransform {
+    transform(value: any, option1: any, option2: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TernaryPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TernaryPipe, "ternary", true>;
+}
+
+declare namespace OSTypes {
+    const WINDOWS: string;
+    const MAC_OS: string;
+    const LINUX: string;
+    const ANDROID: string;
+    const IOS: string;
+    const UNKNOWN: string;
+}
+declare class DeviceDetectorService {
+    #private;
+    userAgent: Nullable<string>;
+    constructor();
+    isMobile(): boolean;
+    isTablet(): boolean;
+    isDesktop(): boolean;
+    getOS(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceDetectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceDetectorService>;
+}
+
+interface IBreakpoints {
+    xl: string;
+    lg: string;
+    md: string;
+    sm: string;
+    xs: string;
+}
+
+/**
+ * A service that manages responsive design breakpoints using Angular's `BreakpointObserver`.
+ * This service provides signals for different screen sizes and allows dynamic
+ * breakpoint management.
+ *
+ * @Injectable
+ */
+declare class BreakpointService {
+    #private;
+    readonly isDesktop: Signal<Nullable<boolean>>;
+    readonly isSmallDesktop: Signal<Nullable<boolean>>;
+    readonly isMobile: Signal<Nullable<boolean>>;
+    readonly isTablet: Signal<Nullable<boolean>>;
+    readonly isSmallTablet: Signal<Nullable<boolean>>;
+    /**
+     * Allows setting custom breakpoints for different screen sizes.
+     *
+     * @param breakpoints - The custom breakpoints to apply.
+     */
+    setBreakpoints(breakpoints: IBreakpoints): void;
+    /**
+     * Helper function to decrement the pixel value by 1.
+     * Used to exclude the exact pixel value in media queries.
+     *
+     * @usageNotes
+     *
+     * This function is useful for setting correct media queries.
+     * E.g. for mobile devices: media query should be `(max-width: 599px)`,
+     * and from `(min-width: 600px)` it should be considered as a tablet.
+     *
+     * @param value - The pixel value to decrement.
+     * @returns The adjusted pixel value as a string.
+     */
+    decrementOnePixel(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreakpointService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreakpointService>;
+}
+
+declare class Breakpoints implements IBreakpoints {
+    readonly xl: string;
+    readonly lg: string;
+    readonly md: string;
+    readonly sm: string;
+    readonly xs: string;
+}
+
+type AsidePositions = 'left' | 'right';
+declare class AsideRef<DATA, ANSWER> {
+    private answer;
+    overlayRef: OverlayRef;
+    component: ComponentType<unknown>;
+    position: AsidePositions;
+    data: DATA;
+    constructor(answer: Subject<ANSWER | null>, overlayRef: OverlayRef, component: ComponentType<unknown>, position: AsidePositions, data: DATA);
+    close(answer?: ANSWER): void;
+}
+declare const ASIDE_REF: InjectionToken<AsideRef<object, object>>;
+declare const ddServices: Array<{
+    provide: string;
+    useValue: unknown;
+}>;
+
+declare const NAVIGATOR: InjectionToken<Navigator>;
+
+declare function checkIsMatchingValues(sample: string): ValidatorFn;
+
+declare function arraysNotEmptyValidator(control: AbstractControl): ValidationErrors | null;
+
+/**
+ * Returns a set of dependency injection providers for utility services.
+ *
+ * @usageNotes
+ *
+ * This function provides utility services that are commonly used across
+ * an Angular application. Specifically, it provides the `BreakpointService`
+ * for managing responsive design breakpoints and the `PlatformService` for
+ * detecting the platform on which the application is running (e.g., browser or server).
+ *
+ * ```typescript
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     provideRtUtils()
+ *   ]
+ * });
+ * ```
+ *
+ * @publicApi
+ */
+declare function provideRtUtils(): Provider[];
+
+export { ASIDE_BUTTONS_ENUM, ASIDE_REF, AsideRef, BaseMapper, BreakStringPipe, BreakpointService, Breakpoints, DASH, DeviceDetectorService, EmptyToDashPipe, EntityToStringPipe, EqualChainPipe, EqualPipe, HAS_OWN_SCOPE_ENUM, IAside, ISideMenu, MODAL_WINDOW_SIZE_ENUM, NAVIGATOR, NotEqualChainPipe, NotEqualPipe, OSTypes, OVERLAY_POSITIONS, POSITION_ENUM, RtEscapeKeyDirective, RtHideTooltipDirective, RtIconOutlinedDirective, RtNavigationDirective, RtScrollDirective, RtScrollToElementDirective, RtTabQueryParamDirective, SanitizePipe, TernaryPipe, TypeCastHelper, areArraysEqual, areArraysEqualUnordered, areObjectsEqual, arraysNotEmptyValidator, checkIsEntityInArrayByKey, checkIsMatchingValues, dateStringToDate, ddServices, debounce, emptyToDash, formatDate, hasPropertyInChain, initToday, isDate, isDateValid, isEmail, isEmpty, isEmptyArray, isEmptyObject, isEmptyString, isEqual, isNumber, isRecord, isString, isToday, parseDate, parseISO, provideRtUtils, removeFieldFromObject, safeComparatorPipe, safeCompare, safeNumCompare, safeStrCompare, sortByAlphabet, sortByDate, stringifyHttpLikeParams, transformArrayInput, transformStringInput };
+export type { AnyObject, AsideButtonsType, AsidePositions, ComparatorType, EmptyObject, IBaseMapper, IBreakpoints, IHasScopeType, IMapper, Icon, IntersectionType, ModalWindowSizeType, Modify, NameValueType, Optional, PartialOmit, Scriptable, ScriptableAndArray, ScriptableAndArrayOptions, ScriptableAndScriptableOptions, ScriptableOptions, Select, ValuesType };