centrifugal 0.0.1

package/index.d.ts

@@ -0,0 +1,4337 @@
+import * as _angular_core from '@angular/core';
+import { ComponentRef, TemplateRef, Signal, ElementRef, DestroyRef, OnInit, Injector, OnDestroy } from '@angular/core';
+import * as i2 from '@angular/common';
+import * as rxjs from 'rxjs';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import * as centrifugal from 'centrifugal';
+import * as i5 from '@angular/cdk/scrolling';
+import { CdkScrollable } from '@angular/cdk/scrolling';
+
+declare enum ScrollbarStates$1 {
+    NORMAL = 0,
+    PRESSED = 1,
+    HOVER = 2
+}
+
+/**
+ * CnScrollBarService
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-bar/cn-scroll-bar-public.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollBarPublicService$1 {
+    private _internalService;
+    get $click(): rxjs.Observable<PointerEvent | MouseEvent>;
+    get $state(): rxjs.Observable<ScrollbarStates$1>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarPublicService$1, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CnScrollBarPublicService$1>;
+}
+
+type ScrollbarState$1 = ScrollbarStates$1;
+
+declare enum ScrollerDirection$2 {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+
+type ScrollerDirections$2 = ScrollerDirection$2 | 'horizontal' | 'vertical';
+
+/**
+ * FloatOrPersentageValue
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/types/float-or-persentage-value.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type FloatOrPersentageValue = number | `${number}%`;
+
+type Operator = '+' | '-';
+/**
+ * ArithmeticExpression
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/types/arithmetic-expression.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type ArithmeticExpression = FloatOrPersentageValue | `${FloatOrPersentageValue}${Operator}${FloatOrPersentageValue}` | `${FloatOrPersentageValue} ${Operator} ${FloatOrPersentageValue}`;
+
+/**
+ * Identifier type
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/types/id.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type Id = string | number;
+
+/**
+ * @license Copyright (c) 2026 Evgenii Alexandrovich Grebennikov (djonnyx@gmail.com tg: http://t.me/djonnyx).
+ */
+type Color = `#${string}` | `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})` | `rgba(#${string},${number})`;
+
+/**
+ * GradientColorPosition
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/types/gradient-position.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type GradientColorPosition = `${number}%` | `${number}` | number | string;
+
+/**
+ * GradientColorPositions
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/types/gradient-positions.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type GradientColorPositions = [GradientColorPosition, GradientColorPosition];
+
+/**
+ * TextDirections.
+ * RTL - right-to-left.
+ * LTR - left-to-right.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/enums/text-directions.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum TextDirections {
+    RTL = "rtl",
+    LTR = "ltr"
+}
+
+/**
+ * TextDirection.
+ * 'rtl' - right-to-left.
+ * 'ltr' - left-to-right.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/enums/text-directions.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type TextDirection = TextDirections | 'rtl' | 'ltr';
+
+/**
+ * LocaleSensitiveDirective
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/directives/cn-locale-sensitive/cn-locale-sensitive.directive.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnLocaleSensitiveDirective {
+    langTextDir: _angular_core.InputSignal<TextDirection>;
+    listDir: _angular_core.InputSignal<ScrollerDirections$2>;
+    private _elementRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnLocaleSensitiveDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CnLocaleSensitiveDirective, "[localeSensitive]", never, { "langTextDir": { "alias": "langTextDir"; "required": false; "isSignal": true; }; "listDir": { "alias": "listDir"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class CnLocaleSensitiveModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnLocaleSensitiveModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnLocaleSensitiveModule, [typeof CnLocaleSensitiveDirective], [typeof i2.CommonModule], [typeof CnLocaleSensitiveDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnLocaleSensitiveModule>;
+}
+
+/**
+ * VirtualClickDirective
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/directives/cn-item-click/cn-item-click.directive.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnVirtualClickDirective {
+    private _$maxDistance;
+    protected $maxDistance: rxjs.Observable<number | null>;
+    private _maxDistance;
+    set maxDistance(v: number | string);
+    onVirtualClick: _angular_core.OutputEmitterRef<PointerEvent | TouchEvent>;
+    onVirtualClickPress: _angular_core.OutputEmitterRef<PointerEvent | TouchEvent>;
+    onVirtualClickCancel: _angular_core.OutputEmitterRef<void>;
+    private _service;
+    private _elementRef;
+    private _destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualClickDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CnVirtualClickDirective, "[virtualClick]", never, { "maxDistance": { "alias": "maxClickDistance"; "required": false; }; }, { "onVirtualClick": "onVirtualClick"; "onVirtualClickPress": "onVirtualClickPress"; "onVirtualClickCancel": "onVirtualClickCancel"; }, never, never, false, never>;
+}
+
+declare class CnVirtualClickModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualClickModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnVirtualClickModule, [typeof CnVirtualClickDirective], [typeof i2.CommonModule], [typeof CnVirtualClickDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnVirtualClickModule>;
+}
+
+/**
+ * IPoint
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/point.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IPoint {
+    /**
+     * X coordinate.
+     */
+    x: number;
+    /**
+     * Y coordinate.
+     */
+    y: number;
+}
+
+/**
+ * Area area Interface
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/interfaces/size.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface ISize {
+    /**
+     * Width value.
+     */
+    width: number;
+    /**
+     * Height value.
+     */
+    height: number;
+}
+
+/**
+ * Rectangular area interface
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/rect.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRect extends ISize {
+    /**
+     * X coordinate.
+     */
+    x: number;
+    /**
+     * Y coordinate.
+     */
+    y: number;
+}
+
+/**
+ * Virtual list element model
+ * For tracking to work correctly, you must set a unique identifier (the property specified by trackBy).
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/item.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type IVirtualListItem<E = Object> = E & {
+    /**
+     * The type of the collection item. Items with different types are cached in separate pools.
+     */
+    type?: string | symbol;
+    /**
+     * Props.
+     */
+    [x: string]: any;
+};
+
+/**
+ * Alignments
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/alignments.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum Alignments {
+    NONE = "none",
+    CENTER = "center"
+}
+
+/**
+ * Alignment
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/alignment.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type Alignment = Alignments | 'none' | 'center';
+
+/**
+ * IAnimationParams
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/animation-params.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IAnimationParams$1 {
+    scrollToItem: number;
+    snapToItem: number;
+    navigateToItem: number;
+    navigateByKeyboard: number;
+}
+
+/**
+ * A value of -1 indicates the direction is up or left (if the list direction is horizontal).
+ * A value of 1 indicates the direction is down or right (if the list direction is horizontal).
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/types/scroll-direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type ScrollDirection$1 = -1 | 1 | 0;
+
+/**
+ * Interface IScrollEvent.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/scroll-event.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollEvent$1 {
+    /**
+     * Scroll area offset
+     */
+    scrollSize: number;
+    /**
+     * Full size of the scroll area
+     */
+    scrollWeight: number;
+    /**
+     * Viewport size
+     */
+    size: number;
+    /**
+     * Size of the list of elements
+     */
+    listSize: number;
+    /**
+     * Specifies whether the list orientation is vertical.
+     */
+    isVertical: boolean;
+    /**
+     * A value of -1 indicates the direction is up or left (if the list direction is horizontal).
+     * A value of 1 indicates the direction is down or right (if the list direction is horizontal).
+     */
+    direction: ScrollDirection$1;
+    /**
+     * If true then indicates that the list has been scrolled to the end.
+     */
+    isStart: boolean;
+    /**
+     * If true then indicates that the list has been scrolled to the end.
+     */
+    isEnd: boolean;
+    /**
+     * Delta of marked and unmarked area
+     */
+    delta: number;
+    /**
+     * Delta of new items
+     */
+    deltaOfNewItems: number;
+    /**
+     * Display items range
+     */
+    itemsRange: [number, number] | undefined;
+    /**
+     * Has user action
+     */
+    userAction: boolean;
+}
+
+/**
+ * Interface IScrollOptions.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/scroll-options.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollOptions$1 {
+    /**
+     * Default value is `0`.
+     */
+    iteration?: number;
+    /**
+     * Scroll behavior. Default value is `instant`.
+     */
+    behavior?: ScrollBehavior | 'auto' | 'instant' | 'smooth';
+    /**
+     * Specifies whether scrolling will smoothly transition to the previous animation. Default value is false.
+     */
+    blending?: boolean;
+    /**
+     * Determines whether the element will have focus after scrolling is complete. Default value is true.
+     */
+    focused?: boolean;
+    /**
+     * Delay.
+     */
+    delay?: number;
+}
+
+/**
+ * IScrollParams
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/scroll-options.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollParams {
+    id: Id;
+    behavior?: ScrollBehavior;
+    blending?: boolean;
+    iteration?: number;
+    isLastIteration?: boolean;
+    scrollCalled?: boolean;
+    delay?: number;
+    cb?: () => void;
+}
+
+/**
+ * Interface IScrollingSettings.
+ * - frictionalForce - Frictional force. Default value is `0.035`.
+ * - mass - Mass. Default value is `0.005`.
+ * - maxDistance - Maximum scrolling distance. Default value is `12500`.
+ * - maxDuration - Maximum animation duration. Default value is `4000`.
+ * - speedScale - Speed scale. Default value is `15`.
+ * - optimization - Enables scrolling performance optimization. Default value is `true`.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/scrolling-settings.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollingSettings$1 {
+    /**
+     * Frictional force. Default value is `0.035`.
+     */
+    frictionalForce?: number;
+    /**
+     * Maximum animation duration. Default value is `4000`.
+     */
+    maxDuration?: number;
+    /**
+     * Mass. Default value is `0.005`.
+     */
+    mass?: number;
+    /**
+     * Maximum scrolling distance. Default value is `12500`.
+     */
+    maxDistance?: number;
+    /**
+     * Speed scale. Default value is `15`.
+     */
+    speedScale?: number;
+    /**
+     * Enables scrolling performance optimization. Default value is `true`.
+     */
+    optimization?: boolean;
+}
+
+/**
+ * IItemTransformation
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/prerender-container/interfaces/item-transformation.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IItemTransformation {
+    x: number;
+    y: number;
+    z: number;
+    rotationX: number;
+    rotationY: number;
+    rotationZ: number;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    opacity: number;
+    filter?: string;
+    blendColor?: Color | null;
+    zIndex: number | string;
+}
+
+/**
+ * Sets `sticky` position, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied.
+ * If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end. Default value is `0`.
+ * `selectable` determines whether an element can be selected or not. Default value is `true`.
+ * `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and collapse elements in front that do not have a `sticky` property.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/item-config-map.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IVirtualListItemConfigMap {
+    [id: string | number]: IVirtualListItemConfig;
+}
+interface IVirtualListItemConfig {
+    /**
+     * Sets `sticky` position for the element. If sticky position is greater than `0`, then `sticky` position is applied.
+     * `1` - position start, `2` - position end.
+     * Default value is `0`.
+     */
+    sticky?: 0 | 1 | 2;
+    /**
+     * Determines whether an element with a `sticky` property greater than zero can collapse and collapse elements in front that do not have a `sticky` property.
+     * Default value is `false`.
+     */
+    collapsable?: boolean;
+    /**
+     * Determines whether an element can be selected or not.
+     * Default value is `true`.
+     */
+    selectable?: boolean;
+    /**
+     * Determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true.
+     * The default value is false.
+     */
+    fullSize?: boolean;
+}
+
+/**
+ * Virtual list elements collection interface
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/collection.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IVirtualListCollection<E = Object> extends Array<IVirtualListItem<E>> {
+}
+
+/**
+ * Display object configuration.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/display-object-config.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IDisplayObjectConfig extends IRenderVirtualListItemConfig {
+    /**
+     * Determines whether the element has focused or not.
+     */
+    focused: boolean;
+    /**
+     * Determines whether the element is selected or not.
+     */
+    selected: boolean;
+    /**
+     * Determines whether the element is collapsed or not.
+     */
+    collapsed: boolean;
+    /**
+     * True if scroll capture occurs.
+     */
+    grabbing: boolean;
+}
+
+/**
+ * Display object metrics.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/display-object-measures.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IDisplayObjectMeasures extends IRect {
+    /**
+     * Item position
+     */
+    position: number;
+    /**
+     * Scroll size
+     */
+    scrollSize: number;
+    /**
+     * Item size
+     */
+    size: number;
+    /**
+     * Bounds size
+     */
+    boundsSize: number;
+    /**
+     * Start position in viewport
+     */
+    absoluteStartPosition: number;
+    /**
+     * Start position in viewport (percent)
+     */
+    absoluteStartPositionPercent: number;
+    /**
+     * End position in viewport
+     */
+    absoluteEndPosition: number;
+    /**
+     * End position in viewport (percent)
+     */
+    absoluteEndPositionPercent: number;
+    /**
+     * Delta is calculated for Snapping Method.ADVANCED
+     */
+    delta: number;
+}
+
+/**
+ * Measures for IRenderVirtualListItem
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/render-item-measures.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRenderVirtualListItemMeasures extends IRect {
+    /**
+     * The X coordinate after transformation.
+     */
+    transformedX: number;
+    /**
+     * The Y coordinate after transformation.
+     */
+    transformedY: number;
+    /**
+     * The Z coordinate.
+     */
+    z: number;
+    /**
+     * Rotation X
+     */
+    rotationX: number;
+    /**
+     * Rotation Y
+     */
+    rotationY: number;
+    /**
+     * Rotation Z
+     */
+    rotationZ: number;
+    /**
+     * Scale X
+     */
+    scaleX: number;
+    /**
+     * Scale Y
+     */
+    scaleY: number;
+    /**
+     * Scale Z
+     */
+    scaleZ: number;
+    /**
+     * Minimal width.
+     */
+    minWidth: number;
+    /**
+     * Minimal height.
+     */
+    minHeight: number;
+    /**
+     * Maximum width.
+     */
+    maxWidth: number;
+    /**
+     * Maximum height.
+     */
+    maxHeight: number;
+    /**
+     * Item position
+     */
+    position: number;
+    /**
+     * Scroll size
+     */
+    scrollSize: number;
+    /**
+     * Maximum scroll size
+     */
+    maCnScrollSize: number;
+    /**
+     * Item size
+     */
+    size: number;
+    /**
+     * Row
+     */
+    row: {
+        size: number;
+        /**
+         * Indicates that the element is odd.
+         */
+        odd: boolean;
+        /**
+         * Indicates that the element is even.
+         */
+        even: boolean;
+    };
+    /**
+     * Bounds size
+     */
+    boundsSize: number;
+    /**
+     * Start position in viewport
+     */
+    absoluteStartPosition: number;
+    /**
+     * Start position in viewport (percent)
+     */
+    absoluteStartPositionPercent: number;
+    /**
+     * End position in viewport
+     */
+    absoluteEndPosition: number;
+    /**
+     * End position in viewport (percent)
+     */
+    absoluteEndPositionPercent: number;
+    /**
+     * Scroll direction.
+     */
+    scrollDirection: ScrollDirection$1;
+    /**
+     * Delta is calculated for Snapping Method.ADVANCED
+     */
+    delta: number;
+}
+
+/**
+ * ItemTransform
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/types/item-transform.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type ItemTransform = (index: number, measures: IRenderVirtualListItemMeasures, config: IRenderVirtualListItemConfig) => IItemTransformation;
+
+/**
+ * Action modes for collection elements.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/collection-modes.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum CollectionModes {
+    /**
+     * When adding elements to the beginning of the collection, the scroll remains at the current position.
+     */
+    NORMAL = "normal",
+    /**
+     * When adding elements to the beginning of the collection, the scroll is shifted by the sum of the sizes of the new elements.
+     */
+    LAZY = "lazy"
+}
+
+/**
+ * Axis of the arrangement of virtual list elements.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/directions.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum Directions$1 {
+    /**
+     * Horizontal axis.
+     */
+    HORIZONTAL = "horizontal",
+    /**
+     * Vertical axis.
+     */
+    VERTICAL = "vertical"
+}
+
+/**
+ * Focus Alignments.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/focus-alignments.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum FocusAlignments {
+    NONE = "none",
+    START = "start",
+    CENTER = "center",
+    END = "end"
+}
+
+/**
+ * Modes for collapsing list items.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/collapsing-modes.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum CollapsingModes {
+    /**
+     * List items are not selectable.
+     */
+    NONE = "none",
+    /**
+     * List items are collapsed one by one.
+     */
+    MULTI_COLLAPSE = "multi-collapse",
+    /**
+     * Accordion collapsible list items.
+     */
+    ACCORDION = "accordion"
+}
+
+/**
+ * Mods for selecting list items.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/selecting-modes.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum SelectingModes {
+    /**
+     * List items are not selectable.
+     */
+    NONE = "none",
+    /**
+     * List items are selected one by one.
+     */
+    SELECT = "select",
+    /**
+     * Multiple selection of list items.
+     */
+    MULTI_SELECT = "multi-select"
+}
+
+/**
+ * SnapToAtemAligns.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/snap-to-item-aligns.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum SnapToItemAligns {
+    /**
+     * An anchor indicates the beginning of an element.
+     */
+    START = "start",
+    /**
+     * The anchor points to the middle of the element.
+     */
+    CENTER = "center",
+    /**
+     * An anchor indicates the end of an element.
+     */
+    END = "end"
+}
+
+/**
+ * Snapping method.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/snapping-method.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum SnappingMethods {
+    /**
+     * The group is rendered on a background.
+     */
+    STANDART = "standart",
+    /**
+     * A mask is applied to the viewport area so that the background is displayed underneath the attached group.
+     */
+    ADVANCED = "advanced"
+}
+
+/**
+ * SpreadingModes.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/spreading-modes.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum SpreadingModes {
+    /**
+     * List elements are ordered according to the collection sequence.
+     */
+    NORMAL = "normal",
+    /**
+     * List elements are ordered cyclically, forming an infinite list.
+     */
+    INFINITY = "infinity"
+}
+
+/**
+ * Focus Alignment
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/types/focus-alignment.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type FocusAlignment = FocusAlignments | 'none' | 'start' | 'center' | 'end';
+
+/**
+ * SnappingDistance
+ * Snapping activation distance. Can be specified as a percentage of the element size or in absolute values.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/types/snapping-distance.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type SnappingDistance = `${number}%` | number;
+
+/**
+ * Action modes for collection elements.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/collection-mode.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type CollectionMode = CollectionModes | 'normal' | 'lazy';
+
+/**
+ * Axis of the arrangement of virtual list elements.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type Direction$1 = Directions$1 | 'horizontal' | 'vertical';
+
+/**
+ * Modes for collapsing list items.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/collapsing-mode.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type CollapsingMode = CollapsingModes | 'none' | 'multi-collapse' | 'accordion';
+
+/**
+ * Modes for selecting list items.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/selecting-mode.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type SelectingMode = SelectingModes | 'none' | 'select' | 'multi-select';
+
+/**
+ * SnapToItemAlign.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/snap-to-item-align.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type SnapToItemAlign = SnapToItemAligns | 'start' | 'center' | 'end';
+
+/**
+ * Snapping method.
+ * 'standart' - Classic group visualization.
+ * 'advanced' - A mask is applied to the viewport area so that the background is displayed underneath the attached group.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/snapping-method.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type SnappingMethod = SnappingMethods | 'standart' | 'advanced';
+
+/**
+ * SpreadingMode
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/spreading-mode.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type SpreadingMode = SpreadingModes | 'normal' | 'infinity';
+
+/**
+ * Object with configuration parameters for IRenderVirtualListItem
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/render-item-config.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRenderVirtualListItemConfig {
+    /**
+     * Determines whether an element is new in the collection.
+     */
+    new: boolean;
+    /**
+     * Indicates that the element is odd.
+     */
+    odd: boolean;
+    /**
+     * Indicates that the element is even.
+     */
+    even: boolean;
+    /**
+     * Determines whether an element with a `sticky` property greater than zero can collapse and collapse elements in front that do not have a `sticky` property.
+     * Default value is `false`.
+     */
+    collapsable: boolean;
+    /**
+     * If greater than 0, the element will have a sticky position with the given zIndex.
+     */
+    sticky: 0 | 1 | 2;
+    /**
+     * Determines whether an element can be selected or not. Default value is `true`.
+     */
+    selectable: boolean;
+    /**
+     * Specifies whether the element will snap.
+     */
+    snap: boolean;
+    /**
+     * Indicates that the element is snapped.
+     */
+    snapped: boolean;
+    /**
+     * Indicates that the element is being shifted by another snap element.
+     */
+    snappedOut: boolean;
+    /**
+     * Indicates that the element is a vertical list item.
+     */
+    isVertical: boolean;
+    /**
+     * Specifies that the element adapts to the size of its content.
+     */
+    dynamic: boolean;
+    /**
+     * Returns true if the snapping method is advanced
+     */
+    isSnappingMethodAdvanced: boolean;
+    /**
+     * layout offset;
+     */
+    layoutOffset: number;
+    /**
+     * layout index offset;
+     */
+    layoutIndexOffset: number;
+    /**
+     * Tab index.
+     */
+    tabIndex: number;
+    /**
+     * z-index
+     */
+    zIndex: string;
+    /**
+     * Opacity.
+     */
+    opacity: number;
+    /**
+     * Filter.
+     */
+    filter?: string;
+    /**
+     * Blend color.
+     */
+    blendColor?: Color | null;
+    /**
+     * Determines whether an element is a stub.
+     */
+    isStub?: boolean;
+    /**
+     * Division number.
+     */
+    divides: number;
+    /**
+     * Snap to an item. The default value is `false`.
+     */
+    snapToItem: boolean;
+    /**
+     * Alignment for snapToItem. Available values ​​are `start`, `center`, and `end`. The default value is `center`.
+     */
+    snapToItemAlign: SnapToItemAlign;
+    /**
+     * Indicates whether the element is the first in the collection.
+     */
+    isFirst: boolean;
+    /**
+     * Indicates whether the element is the last one in the collection.
+     */
+    isLast: boolean;
+    /**
+     * Determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true.
+     */
+    fullSize: boolean;
+    /**
+     * Number of elements in the collection to be visualized.
+     */
+    totalItems: number;
+    /**
+     * Indicates layout inversion.
+     */
+    inverted: boolean;
+}
+
+/**
+ * List screen element model
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/render-item.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRenderVirtualListItem<E = any> {
+    /**
+     * Element index.
+     */
+    index: number;
+    /**
+     * Unique identifier of the element.
+     */
+    id: Id;
+    /**
+     * Element metrics.
+     */
+    measures: IRenderVirtualListItemMeasures;
+    /**
+     * Element data.
+     */
+    data: IVirtualListItem<E>;
+    /**
+     * Previous element data.
+     */
+    previouseData: IVirtualListItem<E>;
+    /**
+     * Next element data.
+     */
+    nextData: IVirtualListItem<E>;
+    /**
+     * Object with configuration parameters for IRenderVirtualListItem.
+     */
+    config: IRenderVirtualListItemConfig;
+}
+
+/**
+ * FocusItemParams
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/types/focus-item-params.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type FocusItemParams = {
+    element: HTMLElement;
+    position: number;
+    align?: FocusAlignment;
+    behavior?: ScrollBehavior;
+};
+
+/**
+ * CnVirtualListPublicService
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/cn-virtual-list-publick.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnVirtualListPublicService {
+    private _internalService;
+    /**
+     * Unique list identifier.
+     */
+    get id(): number;
+    /**
+     * Informs about a click on a list item.
+     */
+    get $virtualClick(): Observable<IRenderVirtualListItem<any> | null>;
+    /**
+     * Informs about the selection of a list item(s).
+     */
+    get $selectedIds(): Observable<Array<Id> | Id | null>;
+    /**
+     * Informs about the collapse (expanding) of a list element(s).
+     */
+    get $collapsedIds(): Observable<Array<Id>>;
+    /**
+     * Informs the focus on the specified list item.
+     */
+    get $focusItem(): Observable<FocusItemParams>;
+    /**
+     * Notifies about the next change detection tick. Works similarly to `setTimeout` with a timeout of 0.
+     */
+    get $tick(): Observable<void>;
+    /**
+     * Specifies a list of selected items.
+     */
+    set selectedIds(ids: Array<Id> | Id | null);
+    /**
+     * Returns a list of selected items.
+     */
+    get selectedIds(): Array<Id> | Id | null;
+    /**
+     * Specifies a list of collapsed elements.
+     */
+    set collapsedIds(ids: Array<Id>);
+    /**
+     * Returns a list of collapsed elements.
+     */
+    get collapsedIds(): Array<Id>;
+    /**
+     * Updates the list
+     * @param immediately - Indicates that the list is updated instantly.
+     */
+    update(immediately?: boolean): void;
+    /**
+     * Selects a list item
+     * @param id
+     * @param selected - If the value is undefined, then the toggle method is executed, if false or true, then the selection/deselection is performed.
+     */
+    select(id: Id, selected?: boolean | undefined): void;
+    /**
+      * Collapse list items
+      * @param id
+      * @param collapsed - If the value is undefined, then the toggle method is executed, if false or true, then the collapse/expand is performed.
+      */
+    collapse(id: Id, collapsed?: boolean | undefined): void;
+    /**
+     * Focus an list item by a given id.
+     */
+    focus(id: Id, align?: FocusAlignment, scrollBehavior?: ScrollBehavior): void;
+    /**
+      * The method scrolls the list to the element with the given `id` and returns the value of the scrolled area.
+      */
+    scrollTo(id: Id, cb?: (() => void) | null, options?: IScrollOptions$1 | null): void;
+    /**
+     * Scrolls the scroll area to the first item in the collection.
+     */
+    scrollToStart(options?: IScrollOptions$1): void;
+    /**
+     * Scrolls the list to the end of the content size.
+     */
+    scrollToEnd(options?: IScrollOptions$1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualListPublicService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CnVirtualListPublicService>;
+}
+
+/**
+ * BaseVirtualListItemComponent
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/list-item/interfaces/template-context.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface ITemplateContext<D = any> {
+    /**
+     * API provider.
+     */
+    api: CnVirtualListPublicService;
+    /**
+     * List item data.
+     */
+    data: D;
+    /**
+     * Data of the previous list item.
+     */
+    prevData: D;
+    /**
+     * Data of the next list item.
+     */
+    nextData: D;
+    /**
+     * List item measurement data.
+     */
+    measures: IDisplayObjectMeasures | null;
+    /**
+     * List item configuration.
+     */
+    config: IDisplayObjectConfig;
+    /**
+     * Indicates a reset state.
+     */
+    reseted: boolean;
+    /**
+     * List item index.
+     */
+    index: number;
+}
+
+/**
+ * Virtual list screen elements collection interface
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/render-collection.model.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRenderVirtualListCollection extends Array<IRenderVirtualListItem> {
+}
+
+declare class CMap<K = string, V = any> {
+    protected _dict: {
+        [k: string | number]: V;
+    };
+    constructor(dict?: CMap<K, V>);
+    from(dict?: CMap<K, V>): void;
+    get(key: K): V;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    delete(key: K): void;
+    clear(): void;
+    toObject(): {
+        [k: string]: V;
+        [k: number]: V;
+    };
+}
+
+/**
+ * Easing
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/utils/animator/types/easing.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type Easing = (v: number) => number;
+
+/**
+ * IAnimatorUpdateData
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/utils/animator/interfaces/animator-update-data.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IAnimatorUpdateData {
+    id: number;
+    timestamp: number;
+    elapsed: number;
+    delta: number;
+    value: number;
+}
+
+/**
+ * IAnimatorParams
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/utils/animator/interfaces/animator-params.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IAnimatorParams {
+    startValue: number;
+    endValue: number;
+    duration?: number;
+    withDelta?: boolean;
+    getPropValue?: () => number;
+    easingFunction?: Easing;
+    onUpdate?: (data: IAnimatorUpdateData) => void;
+    onComplete?: (data: IAnimatorUpdateData) => void;
+}
+
+/**
+ * Animator
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/utils/animator/animator.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class Animator {
+    private static _nextId;
+    private _animationId;
+    get animated(): boolean;
+    get isAnimated(): boolean;
+    private _currentId;
+    get id(): number;
+    private generateId;
+    private _diff;
+    private _startValue;
+    private _endValue;
+    private _prevPos;
+    updateTo(end: number): boolean;
+    animate(params: IAnimatorParams): number;
+    hasAnimation(id?: number): boolean;
+    stop(id?: number): void;
+    dispose(): void;
+}
+
+type TEventHandler = (...args: Array<any>) => void;
+/**
+ * Event emitter
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/common/utils/event-emitter/event-emitter.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class EventEmitter<E = string, H = TEventHandler> {
+    protected _listeners: {
+        [eventName: string]: Array<TEventHandler>;
+    };
+    protected _disposed: boolean;
+    constructor();
+    /**
+     * Emits the event
+     */
+    dispatch(event: E, ...args: Array<any>): void;
+    /**
+     * Emits the event async
+     */
+    dispatchAsync(event: E, ...args: Array<any>): void;
+    /**
+     * Returns true if the event listener is already subscribed.
+     */
+    hasEventListener(eventName: E, handler: H): boolean;
+    /**
+     * Add event listener
+     */
+    addEventListener(eventName: E, handler: H): void;
+    /**
+     * Remove event listener
+     */
+    removeEventListener(eventName: E, handler: H): void;
+    /**
+     * Remove all listeners
+     */
+    removeAllListeners(): void;
+    /**
+     * Method of destroying handlers
+     */
+    dispose(): void;
+}
+
+interface ICacheMap<I = any, B = any> {
+    set: (id: I, bounds: B) => CMap<I, B>;
+    has: (id: I) => boolean;
+    get: (id: I) => B | undefined;
+    delete: (id: I) => void;
+    clear: () => void;
+}
+declare const CACHE_BOX_CHANGE_EVENT_NAME = "change";
+type CacheMapEvents$1 = typeof CACHE_BOX_CHANGE_EVENT_NAME;
+type OnChangeEventListener$1 = (version: number) => void;
+type CacheMapListeners$1 = OnChangeEventListener$1;
+/**
+ * Cache map.
+ * Emits a change event on each mutation.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/cache-map.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CacheMap<I = string | number, B = any, E = CacheMapEvents$1, L = CacheMapListeners$1> extends EventEmitter<E, L> implements ICacheMap {
+    protected _map: CMap<I, B>;
+    protected _snapshot: CMap<I, B>;
+    protected _version: number;
+    protected _previousVersion: number;
+    protected _lifeCircleId: any;
+    protected _delta: number;
+    get delta(): number;
+    get version(): number;
+    constructor();
+    protected changesDetected(): boolean;
+    protected stopLifeCircle(): void;
+    protected nextTick(cb: () => void): any;
+    protected lifeCircle(): void;
+    protected lifeCircleDo(): void;
+    protected bumpVersion(): void;
+    protected fireChangeIfNeed(): void;
+    set(id: I, bounds: B): CMap<I, B>;
+    has(id: I): boolean;
+    get(id: I): B | undefined;
+    delete(id: I): void;
+    clear(): void;
+    snapshot(): void;
+    dispose(): void;
+}
+
+type TrackingPropertyId = string | number;
+/**
+ * Tracks display items by property
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/tracker.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class Tracker<C extends BaseVirtualListItemComponent = any> {
+    /**
+     * display objects dictionary of indexes by id
+     */
+    protected _displayObjectIndexMapById: {
+        [id: number]: number;
+    };
+    set displayObjectIndexMapById(v: {
+        [id: number]: number;
+    });
+    get displayObjectIndexMapById(): {
+        [id: number]: number;
+    };
+    /**
+     * Dictionary displayItems propertyNameId by items propertyNameId
+     */
+    protected _trackMap: CMap<TrackingPropertyId, number>;
+    get trackMap(): CMap<TrackingPropertyId, number>;
+    protected _trackingPropertyName: string;
+    set trackingPropertyName(v: string);
+    constructor(trackingPropertyName: string);
+    private tearOutSnapedDisplayObjectByItemId;
+    /**
+     * tracking by propName
+     */
+    track(items: IRenderVirtualListCollection, components: Array<ComponentRef<C>>, snappedComponents: Array<ComponentRef<C>> | null | undefined, direction: ScrollDirection$1, trackBy: string): void;
+    untrackComponentByIdProperty(component?: C): void;
+    clearTrackMap(): void;
+    dispose(): void;
+}
+
+/**
+ * PrerenderCache
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/prerender-container/types/cache.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type PrerenderCache = {
+    [id: Id]: ISize;
+};
+
+declare const WIDTH_PROP_NAME = "width";
+declare const HEIGHT_PROP_NAME = "height";
+
+/**
+ * IItem
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/interfaces/item.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IItem<I = any> {
+    [prop: string]: I;
+}
+
+/**
+ * IMetrics
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/interfaces/metrics.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IMetrics<I extends IItem> {
+    delta: number;
+    inverted: boolean;
+    normalizedItemWidth: number;
+    normalizedItemHeight: number;
+    width: number;
+    height: number;
+    dynamicSize: boolean;
+    divides: number;
+    itemSize: number;
+    minItemSize: number;
+    maxItemSize: number;
+    items: Array<I>;
+    itemsFromStartToScrollEnd: number;
+    itemsFromStartToDisplayEnd: number;
+    itemsOnDisplayWeight: number;
+    itemsOnDisplayLength: number;
+    isVertical: boolean;
+    leftHiddenItemsWeight: number;
+    leftItemLength: number;
+    leftItemsWeight: number;
+    leftLayoutOffset: number;
+    leftLayoutIndexOffset: number;
+    renderItems: number;
+    rightItemLength: number;
+    rightItemsWeight: number;
+    scrollSize: number;
+    maCnScrollSize: number;
+    leftSizeOfAddedItems: number;
+    sizeProperty: typeof HEIGHT_PROP_NAME | typeof WIDTH_PROP_NAME;
+    stickyEnabled: boolean;
+    stickyPos: number;
+    startIndex: number;
+    startPosition: number;
+    totalItemsToDisplayEndWeight: number;
+    totalLength: number;
+    totalSize: number;
+    typicalItemSize: number;
+    isFromItemIdFound: boolean;
+    isUpdating: boolean;
+    snapToItem: boolean;
+    snapToItemAlign: SnapToItemAlign;
+    itemTransform: ItemTransform | null;
+}
+
+/**
+ * IRecalculateMetricsOptions
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/interfaces/recalculate-metrics-options.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IRecalculateMetricsOptions<I extends IItem, C extends Array<I>> {
+    alignment: Alignment;
+    bounds: ISize;
+    collection: C;
+    isVertical: boolean;
+    itemSize: number;
+    minItemSize: number;
+    maxItemSize: number;
+    bufferSize: number;
+    maxBufferSize: number;
+    dynamicSize: boolean;
+    scrollSize: number;
+    stickyEnabled: boolean;
+    enabledBufferOptimization: boolean;
+    fromItemId?: Id;
+    previousTotalSize: number;
+    crudDetected: boolean;
+    deletedItemsMap: {
+        [index: number]: ISize;
+    };
+    snapToItem: boolean;
+    snapToItemAlign: SnapToItemAlign;
+    inverted: boolean;
+    itemTransform: ItemTransform | null;
+}
+
+/**
+ * IGetItemPositionOptions
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/interfaces/get-item-position-options.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IGetItemPositionOptions<I extends IItem, C extends Array<I>> extends Omit<IRecalculateMetricsOptions<I, C>, 'previousTotalSize' | 'crudDetected' | 'deletedItemsMap'> {
+}
+
+/**
+ * IUpdateCollectionOptions
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/interfaces/update-collection-options.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IUpdateCollectionOptions<I extends IItem, C extends Array<I>> extends Omit<IRecalculateMetricsOptions<I, C>, 'collection' | 'previousTotalSize' | 'crudDetected' | 'deletedItemsMap'> {
+}
+
+/**
+ * IGetMetricsReturns
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/interfaces/get-metrics-returns.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IGetMetricsReturns {
+    totalSize: number;
+    delta: number;
+    crudDetected: boolean;
+}
+
+/**
+ * IUpdateCollectionReturns
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/interfaces/update-collection-returns.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IUpdateCollectionReturns {
+    displayItems: IRenderVirtualListCollection;
+    totalSize: number;
+    leftLayoutOffset: number;
+    delta: number;
+    crudDetected: boolean;
+}
+
+/**
+ * ItemDisplayMethods
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/enums/item-display-methods.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum ItemDisplayMethods {
+    CREATE = 0,
+    UPDATE = 1,
+    DELETE = 2,
+    NOT_CHANGED = 3
+}
+
+/**
+ * Cache
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/types/cache.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type Cache = ISize & {
+    method?: ItemDisplayMethods;
+} & IItem;
+
+/**
+ * TrackBoxEvents
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/events/track-box-events.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum TrackBoxEvents {
+    CHANGE = "change",
+    TICK = "tick"
+}
+
+/**
+ * CacheMapEvents
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/types/cache-map-events.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type CacheMapEvents = TrackBoxEvents;
+
+/**
+ * OnChangeEventListener
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/types/on-change-event-listener.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type OnChangeEventListener = (version: number) => void;
+
+/**
+ * OnTickEventListener
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/types/on-tick-event-listener.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type OnTickEventListener = () => void;
+
+/**
+ * CacheMapListeners
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/types/cache-map-listeners.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type CacheMapListeners = OnChangeEventListener | OnTickEventListener;
+
+/**
+ * An object that performs tracking, calculations and caching.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/core/track-box.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class TrackBox<C extends BaseVirtualListItemComponent = any> extends CacheMap<Id, Cache, CacheMapEvents, CacheMapListeners> {
+    protected _tracker: Tracker<C>;
+    protected _items: IRenderVirtualListCollection | null | undefined;
+    set items(v: IRenderVirtualListCollection | null | undefined);
+    protected _displayComponents: Array<ComponentRef<C>> | null | undefined;
+    set displayComponents(v: Array<ComponentRef<C>> | null | undefined);
+    protected _snappedDisplayComponents: Array<ComponentRef<C>> | null | undefined;
+    set snappedDisplayComponents(v: Array<ComponentRef<C>> | null | undefined);
+    protected _scrollDirection: ScrollDirection$1;
+    set scrollDirection(v: ScrollDirection$1);
+    get scrollDirection(): ScrollDirection$1;
+    protected _trackBy: string;
+    set trackBy(v: string);
+    get trackBy(): string;
+    protected _divides: number;
+    set divides(v: number);
+    protected _isInfinity: boolean;
+    set isInfinity(v: boolean);
+    protected _isSnappingMethodAdvanced: boolean;
+    set isSnappingMethodAdvanced(v: boolean);
+    protected _isLazy: boolean;
+    set isLazy(v: boolean);
+    /**
+     * Set the trackBy property
+     */
+    set trackingPropertyName(v: string);
+    protected _trackingPropertyName: string;
+    protected _isScrollStart: boolean;
+    set isScrollStart(v: boolean);
+    protected _isScrollEnd: boolean;
+    set isScrollEnd(v: boolean);
+    protected _isScrollSnapToStart: boolean;
+    get isSnappedToStart(): boolean;
+    protected _isScrollSnapToEnd: boolean;
+    get isSnappedToEnd(): boolean;
+    protected _scrollStartOffset: number;
+    set scrollStartOffset(v: number);
+    get scrollStartOffset(): number;
+    protected _scrollEndOffset: number;
+    set scrollEndOffset(v: number);
+    get scrollEndOffset(): number;
+    constructor(trackingPropertyName: string);
+    protected initialize(): void;
+    set(id: Id, cache: Cache): CMap<Id, ISize>;
+    protected _previousCollection: Array<IItem> | null | undefined;
+    protected _deletedItemsMap: {
+        [index: number]: ISize;
+    };
+    protected _crudDetected: boolean;
+    get crudDetected(): boolean;
+    protected fireChangeIfNeed(): void;
+    protected fireTick(): void;
+    protected _previousTotalSize: number;
+    protected _deltaOfNewItems: number;
+    get deltaOfNewItems(): number;
+    isAdaptiveBuffer: boolean;
+    protected _bufferSequenceExtraThreshold: number;
+    protected _maxBufferSequenceLength: number;
+    protected _bufferSizeSequence: Array<number>;
+    protected _bufferSize: number;
+    get bufferSize(): number;
+    protected _defaultBufferSize: number;
+    protected _maxBufferSize: number;
+    protected _resetBufferSizeTimeout: number;
+    protected _resetBufferSizeTimer: number | undefined;
+    protected _isReseted: boolean;
+    private _prerenderedCache;
+    private _newItems;
+    protected lifeCircle(): void;
+    /**
+     * Scans the collection for deleted items and flushes the deleted item cache.
+     */
+    resetCollection<I extends IItem, C extends Array<I>>(currentCollection: C | null | undefined, itemSize: number): void;
+    /**
+     * Update the cache of items from the list
+     */
+    protected updateCache<I extends IItem, C extends Array<I>>(previousCollection: C | null | undefined, currentCollection: C | null | undefined, itemSize: number): void;
+    /**
+     * Finds the position of a collection element by the given Id
+     */
+    getItemPosition<I extends IItem, C extends Array<I>>(id: Id, itemConfigMap: IVirtualListItemConfigMap, options: IGetItemPositionOptions<I, C>): number;
+    preventScrollSnapping(clearBuffer?: boolean): void;
+    /**
+     * Updates the collection of display objects
+     */
+    getMetrics<I extends IItem, C extends Array<I>>(items: C, itemConfigMap: IVirtualListItemConfigMap, options: IUpdateCollectionOptions<I, C>): IGetMetricsReturns;
+    /**
+     * Updates the collection of display objects
+     */
+    updateCollection<I extends IItem, C extends Array<I>>(items: C, itemConfigMap: IVirtualListItemConfigMap, options: IUpdateCollectionOptions<I, C>): IUpdateCollectionReturns;
+    protected _previousScrollSize: number;
+    protected updateAdaptiveBufferParams<I extends IItem>(metrics: IMetrics<I>, totalItemsLength: number): void;
+    protected startResetBufferSizeTimer(): void;
+    protected disposeClearBufferSizeTimer(): void;
+    /**
+     * Calculates the entry into the overscroll area and returns the number of overscroll elements
+     */
+    protected getElementNumToEnd<I extends IItem, C extends Array<I>>(i: number, collection: C, map: CMap<Id, ISize>, typicalItemSize: number, size: number, isVertical: boolean, indexOffset?: number, reverse?: boolean): {
+        num: number;
+        offset: number;
+    };
+    /**
+     * Calculates list metrics
+     */
+    protected recalculateMetrics<I extends IItem, C extends Array<I>>(options: IRecalculateMetricsOptions<I, C>): IMetrics<I>;
+    refreshCache(cache: PrerenderCache): void;
+    clearDelta(): void;
+    changes(immediately?: boolean, force?: boolean): void;
+    /**
+     * Returns true if the bounds of at least one screen object have changed.
+     */
+    checkBoundsOfElements(): boolean;
+    protected generateDisplayCollection<I extends IItem, C extends Array<I>>(items: C, actualItems: C, itemConfigMap: IVirtualListItemConfigMap, metrics: IMetrics<I>): IRenderVirtualListCollection;
+    resetPositions(): void;
+    /**
+     * tracking by propName
+     */
+    track(): void;
+    setDisplayObjectIndexMapById(v: {
+        [id: number]: number;
+    }): void;
+    untrackComponentByIdProperty(component?: C | undefined): void;
+    getItemBounds(id: Id): ISize | null;
+    getComponentBoundsByIntersectionPosition(position: number, maxPosition?: number | null): (IRect & {
+        id: Id | null;
+        isFirst: boolean;
+        isLast: boolean;
+    }) | null;
+    private _debouncedIsScrollStartOff;
+    protected cacheElements(isVertical: boolean, itemSize: number): void;
+    resetCacheChunkInfo(): void;
+    cacheClean(): void;
+    dispose(): void;
+}
+
+/**
+ * Mods for selecting list items.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/enums/selecting-modes-types.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum SelectingModesTypes {
+    /**
+     * List items are not selectable.
+     */
+    NONE = 0,
+    /**
+     * List items are selected one by one.
+     */
+    SELECT = 1,
+    /**
+     * Multiple selection of list items.
+     */
+    MULTI_SELECT = 2
+}
+
+interface IScrollToParams$2 {
+    id: Id;
+    cb: (() => void) | null;
+    options: IScrollOptions$1 | null;
+}
+
+/**
+ * CnVirtualListService
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/cn-virtual-list.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnVirtualListService {
+    private _id;
+    get id(): number;
+    private _nextComponentId;
+    private _$virtualClick;
+    $virtualClick: rxjs.Observable<IRenderVirtualListItem<any> | null>;
+    private _$selectedIds;
+    $selectedIds: rxjs.Observable<Id | Id[] | null>;
+    private _$collapsedIds;
+    $collapsedIds: rxjs.Observable<Id[]>;
+    private _$selectingMode;
+    $selectingMode: rxjs.Observable<SelectingModesTypes>;
+    set selectingMode(v: SelectingModesTypes);
+    private _$focusedId;
+    $focusedId: rxjs.Observable<Id | null>;
+    set focusedId(v: Id | null);
+    get focusedId(): Id | null;
+    private _$focusItem;
+    readonly $focusItem: rxjs.Observable<FocusItemParams>;
+    private _$scrollTo;
+    readonly $scrollTo: rxjs.Observable<IScrollToParams$2 | undefined>;
+    private _$scrollToStart;
+    readonly $scrollToStart: rxjs.Observable<IScrollOptions$1 | undefined>;
+    private _$scrollToEnd;
+    readonly $scrollToEnd: rxjs.Observable<IScrollOptions$1 | undefined>;
+    private _$tick;
+    readonly $tick: rxjs.Observable<void>;
+    private _$cacheVersion;
+    readonly $cacheVersion: rxjs.Observable<number>;
+    trackBy: string;
+    lastFocusedItemId: number;
+    scrollStartOffset: number;
+    scrollEndOffset: number;
+    zIndexWhenSelecting: string | null;
+    selectByClick: boolean;
+    collapseByClick: boolean;
+    defaultItemValue: IVirtualListItem | null;
+    snapToItem: boolean;
+    isInfinity: boolean;
+    isVertical: boolean;
+    dynamic: boolean;
+    itemSize: number;
+    snapScrollToStart: boolean;
+    snapScrollToEnd: boolean;
+    animationParams: IAnimationParams$1;
+    isNoneCollapse: boolean;
+    isMultipleCollapse: boolean;
+    isAccordionCollapse: boolean;
+    private _trackBox;
+    listElement: HTMLDivElement | null;
+    items: IVirtualListCollection;
+    itemConfigMap: IVirtualListItemConfigMap;
+    private _$displayItems;
+    readonly $displayItems: rxjs.Observable<IRenderVirtualListCollection>;
+    get displayItems(): IRenderVirtualListCollection;
+    private _collection;
+    set collection(v: IRenderVirtualListCollection);
+    get collection(): IRenderVirtualListCollection;
+    private _$langTextDir;
+    readonly $langTextDir: rxjs.Observable<TextDirection>;
+    get langTextDir(): TextDirection;
+    private _langTextDir;
+    set langTextDir(v: TextDirection);
+    private _$grabbing;
+    readonly $grabbing: rxjs.Observable<boolean>;
+    get grabbing(): boolean;
+    private _grabbing;
+    set grabbing(v: boolean);
+    private _$clickPressed;
+    readonly $clickPressed: rxjs.Observable<boolean>;
+    get clickPressed(): boolean;
+    private _clickPressed;
+    set clickPressed(v: boolean);
+    private _$isGrabbing;
+    readonly $isGrabbing: rxjs.Observable<boolean>;
+    get isGrabbing(): boolean;
+    get scrollBarSize(): number;
+    private _scrollBarSize;
+    set scrollBarSize(v: number);
+    private _$scrollBarSize;
+    readonly $scrollBarSize: rxjs.Observable<number>;
+    private _$intersectionElementBySnapToItemAlign;
+    readonly $intersectionElementBySnapToItemAlign: rxjs.Observable<Id | null>;
+    private _$clickDistance;
+    readonly $clickDistance: rxjs.Observable<number>;
+    get clickDistance(): number;
+    private _clickDistance;
+    set clickDistance(v: number);
+    private _onTickHandler;
+    private _onTrackBoxChangeHandler;
+    set selectedIds(ids: Array<Id> | Id | null);
+    get selectedIds(): Array<Id> | Id | null;
+    set collapsedIds(ids: Array<Id>);
+    get collapsedIds(): Array<Id>;
+    constructor();
+    virtualClick(data: IRenderVirtualListItem | null): void;
+    update(immediately?: boolean): void;
+    private getItemConfig;
+    /**
+     * Selects a list item
+     * @param id
+     * @param selected - If the value is undefined, then the toggle method is executed, if false or true, then the selection/deselection is performed.
+     */
+    select(id: Id, selected?: boolean): void;
+    /**
+      * Collapse list items
+      * @param data
+      * @param collapsed - If the value is undefined, then the toggle method is executed, if false or true, then the collapse/expand is performed.
+      */
+    collapse(id: Id, collapsed?: boolean): void;
+    getFocusedElementById(id: Id): HTMLDivElement | null;
+    /**
+     * Returns the bounds of an element with a given id
+     */
+    getItemBounds(id: Id): ISize | null;
+    /**
+     * Focus an list item by a given id.
+     */
+    focusById(id: Id, align?: FocusAlignment, scrollBehavior?: ScrollBehavior): void;
+    focus(element: HTMLElement, align?: FocusAlignment, behavior?: ScrollBehavior): boolean;
+    focusList(): void;
+    focusFirstElement(): void;
+    initialize(id: number, trackBox: TrackBox): void;
+    generateComponentId(): number;
+    getComponentBoundsByIntersectionPosition(position: number, maxPosition?: number | null): (IRect & {
+        id: Id | null;
+        isFirst: boolean;
+        isLast: boolean;
+    }) | null;
+    setIntersectionElementBySnapToItemAlign(id: Id | null): void;
+    /**
+      * The method scrolls the list to the element with the given `id` and returns the value of the scrolled area.
+      */
+    scrollTo(id: Id, cb?: (() => void) | null, options?: IScrollOptions$1 | null): void;
+    /**
+     * Scrolls the scroll area to the first item in the collection.
+     */
+    scrollToStart(options?: IScrollOptions$1): void;
+    /**
+     * Scrolls the list to the end of the content size.
+     */
+    scrollToEnd(options?: IScrollOptions$1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualListService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CnVirtualListService>;
+}
+
+/**
+ * IBaseVirtualListItemComponent
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/interfaces/base-virtual-list-item-component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IBaseVirtualListItemComponent {
+    get id(): number;
+    regular: boolean;
+    set regularLength(v: string);
+    set item(v: IRenderVirtualListItem | null | undefined);
+    get item(): IRenderVirtualListItem | null | undefined;
+    get itemId(): Id | undefined;
+    set renderer(v: TemplateRef<any> | undefined);
+    get element(): HTMLElement;
+    getBounds(): ISize;
+    show(): void;
+    hide(): void;
+}
+
+/**
+ * BaseVirtualListItemComponent
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/list-item/base/base-virtual-list-item-component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class BaseVirtualListItemComponent implements IBaseVirtualListItemComponent {
+    protected _item: Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected _container: Signal<ElementRef<HTMLDivElement> | undefined>;
+    private _apiService;
+    protected readonly _service: CnVirtualListService;
+    protected _id: number;
+    get id(): number;
+    protected _listId: number;
+    get listId(): number;
+    protected _displayId: string;
+    get displayId(): string;
+    protected _isSelected: boolean;
+    set isSelected(v: boolean);
+    get isSelected(): boolean;
+    protected _isCollapsed: boolean;
+    protected readonly config: _angular_core.WritableSignal<IDisplayObjectConfig>;
+    protected readonly measures: _angular_core.WritableSignal<IDisplayObjectMeasures | null>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly part: _angular_core.WritableSignal<string>;
+    protected readonly fxPart: _angular_core.WritableSignal<string>;
+    protected readonly data: _angular_core.WritableSignal<IRenderVirtualListItem<any> | null>;
+    protected _data: IRenderVirtualListItem | null;
+    set item(v: IRenderVirtualListItem | null);
+    protected readonly classes: Signal<{
+        [cName: string]: boolean;
+    }>;
+    protected readonly index: Signal<number>;
+    protected readonly templateContext: Signal<ITemplateContext>;
+    regular: boolean;
+    protected _blendColor: Color | null;
+    protected _scrollBarSize: number;
+    protected _langTextDir: TextDirection;
+    protected _regularLength: string;
+    set regularLength(v: string);
+    get item(): IRenderVirtualListItem | null;
+    get itemId(): centrifugal.Id | undefined;
+    get zIndex(): string;
+    get visibility(): string;
+    protected readonly itemRenderer: _angular_core.WritableSignal<TemplateRef<any> | undefined>;
+    protected _renderer: TemplateRef<any> | undefined;
+    set renderer(v: TemplateRef<any> | undefined);
+    protected _elementRef: ElementRef<HTMLElement>;
+    get element(): HTMLElement;
+    protected _destroyRef: DestroyRef;
+    constructor();
+    protected updateMeasures(v: IRenderVirtualListItem<any> | null): void;
+    protected updateConfig(v: IRenderVirtualListItem<any> | null, grabbing: boolean): void;
+    protected update(): void;
+    protected updatePartStr(v: IRenderVirtualListItem | null, isSelected: boolean, isCollapsed: boolean): void;
+    protected hasFocus(): boolean;
+    getBounds(): ISize;
+    show(): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseVirtualListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseVirtualListItemComponent, "x-base-virtual-list-item", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Virtual list component.
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-list-item/cn-virtual-list-item.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnVirtualListItemComponent extends BaseVirtualListItemComponent implements OnInit {
+    protected readonly maxClickDistance: _angular_core.WritableSignal<number>;
+    protected _injector: Injector;
+    constructor();
+    ngOnInit(): void;
+    private keyKode;
+    private getNavigationTimeout;
+    private toNextItem;
+    private toPrevItem;
+    private focusNext;
+    private focusPrev;
+    protected updateConfig(v: IRenderVirtualListItem<any> | null, grabbing: boolean): void;
+    onClickHandler(): void;
+    onClickPressHandler(): void;
+    onClickCancelHandler(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnVirtualListItemComponent, "cn-virtual-list-item", never, {}, {}, never, never, false, never>;
+}
+
+interface Component$1<T> extends Function {
+    new (...args: any[]): T;
+}
+
+/**
+ * Virtual list component.
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/cn-virtual-list.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnVirtualListComponent implements OnDestroy {
+    private static __nextId;
+    private _id;
+    /**
+     * Readonly. Returns the unique identifier of the component.
+     */
+    get id(): number;
+    private _service;
+    private _prerender;
+    private _listContainerRef;
+    private _snapContainerRef;
+    private _scrollerComponent;
+    private _scroller;
+    private _list;
+    /**
+     * Fires when the list has been scrolled.
+     */
+    onScroll: _angular_core.OutputEmitterRef<IScrollEvent$1>;
+    /**
+     * Fires when the list has completed scrolling.
+     */
+    onScrollEnd: _angular_core.OutputEmitterRef<IScrollEvent$1>;
+    /**
+     * Fires when the viewport size is changed.
+     */
+    onViewportChange: _angular_core.OutputEmitterRef<ISize>;
+    /**
+     * Emit the component ID when an element crosses the alignment line specified by the snapToItemAlign property.
+     */
+    onSnapItem: _angular_core.OutputEmitterRef<Id>;
+    /**
+     * Fires when an element is clicked.
+     */
+    onItemClick: _angular_core.OutputEmitterRef<IRenderVirtualListItem<any> | null>;
+    /**
+     * Fires when elements are selected.
+     */
+    onSelect: _angular_core.OutputEmitterRef<Id | Id[] | null>;
+    /**
+     * Fires when elements are collapsed.
+     */
+    onCollapse: _angular_core.OutputEmitterRef<Id | Id[] | null>;
+    /**
+     * Fires when the scroll reaches the start.
+     */
+    onScrollReachStart: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Fires when the scroll reaches the end.
+     */
+    onScrollReachEnd: _angular_core.OutputEmitterRef<void>;
+    private _$show;
+    readonly $show: rxjs.Observable<boolean>;
+    private _$initialized;
+    readonly $initialized: rxjs.Observable<boolean>;
+    private _scrollbarThickness;
+    /**
+     * Scrollbar thickness.
+     */
+    scrollbarThickness: _angular_core.InputSignal<number>;
+    private _scrollbarMinSize;
+    /**
+     * Minimum scrollbar size.
+     */
+    scrollbarMinSize: _angular_core.InputSignal<number>;
+    private _scrollbarThumbRenderer;
+    /**
+     * Scrollbar customization template.
+     */
+    scrollbarThumbRenderer: _angular_core.InputSignal<TemplateRef<any> | null>;
+    private _scrollbarThumbParams;
+    /**
+     * Additional options for the scrollbar.
+     */
+    scrollbarThumbParams: _angular_core.InputSignal<{
+        [propName: string]: any;
+    } | null>;
+    private _loading;
+    /**
+     * If `true`, the scrollBar goes into loading state. The default value is `false`.
+     */
+    loading: _angular_core.InputSignal<boolean>;
+    private _waitForPreparation;
+    /**
+     * If true, it will wait until the list items are fully prepared before displaying them.. The default value is `true`.
+     */
+    waitForPreparation: _angular_core.InputSignal<boolean>;
+    private _clickDistance;
+    /**
+     * The maximum scroll distance at which a click event is triggered.
+     */
+    clickDistance: _angular_core.InputSignal<number>;
+    private _itemsOptions;
+    /**
+     * Collection of list items.
+     */
+    items: _angular_core.InputSignal<IVirtualListCollection<Object>>;
+    private _selectedIdsOptions;
+    defaultItemValue: _angular_core.InputSignal<IVirtualListItem | null>;
+    /**
+     * Sets the selected items.
+     */
+    selectedIds: _angular_core.InputSignal<Id | Id[] | null>;
+    private _collapsedIdsOptions;
+    /**
+     * Sets the collapsed items.
+     */
+    collapsedIds: _angular_core.InputSignal<Id[]>;
+    private _selectByClickOptions;
+    /**
+     * If `false`, the element is selected using the api.select method passed to the template;
+     * if `true`, the element is selected by clicking on it. The default value is `true`.
+     */
+    selectByClick: _angular_core.InputSignal<boolean>;
+    private _collapseByClickOptions;
+    /**
+     * If `false`, the element is collapsed using the config.collapse method passed to the template;
+     * if `true`, the element is collapsed by clicking on it. The default value is `true`.
+     */
+    collapseByClick: _angular_core.InputSignal<boolean>;
+    private _snapOptions;
+    /**
+     * @deprecated
+     * Use the `stickyEnabled` property instead.
+     */
+    snap: _angular_core.InputSignal<boolean>;
+    private _stickyEnabledOptions;
+    /**
+     * Determines whether items with the given `sticky` in `itemConfigMap` will stick to the edges. Default value is "true".
+     */
+    stickyEnabled: _angular_core.InputSignal<boolean>;
+    private _snapToEndTransitionInstantOffsetOptions;
+    /**
+     * Sets the offset value; if the scroll area value is exceeded, the scroll animation will be disabled. Default value is "0".
+     */
+    snapToEndTransitionInstantOffset: _angular_core.InputSignal<number>;
+    private _scrollStartOffsetOptions;
+    /**
+     * Sets the scroll start offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    scrollStartOffset: _angular_core.InputSignal<ArithmeticExpression>;
+    private _scrollEndOffsetOptions;
+    /**
+     * Sets the scroll end offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    scrollEndOffset: _angular_core.InputSignal<ArithmeticExpression>;
+    private _snapScrollToStartOptions;
+    /**
+     * Determines whether the scroll will be anchored to the start of the list. Default value is "true".
+     * This property takes precedence over the snapScrollToEnd property.
+     * That is, if snapScrollToStart and snapScrollToEnd are enabled, the list will initially snap
+     * to the beginning; if you move the scroll bar to the end, the list will snap to the end.
+     * If snapScrollToStart is disabled and snapScrollToEnd is enabled, the list will snap to the end;
+     * if you move the scroll bar to the beginning, the list will snap to the beginning.
+     * If both snapScrollToStart and snapScrollToEnd are disabled, the list will never snap to the beginning or end.
+     * In the `spreadingMode=SpreadingModes.INFINITY` mode, the `snapScrollToStart` property is automatically disabled, since the list has no beginning or end.
+     */
+    snapScrollToStart: _angular_core.InputSignal<boolean>;
+    private _snapScrollToEndOptions;
+    /**
+     * Determines whether the scroll will be anchored to the утв of the list. Default value is "true".
+     * That is, if snapScrollToStart and snapScrollToEnd are enabled, the list will initially snap
+     * to the beginning; if you move the scroll bar to the end, the list will snap to the end.
+     * If snapScrollToStart is disabled and snapScrollToEnd is enabled, the list will snap to the end;
+     * if you move the scroll bar to the beginning, the list will snap to the beginning.
+     * If both snapScrollToStart and snapScrollToEnd are disabled, the list will never snap to the beginning or end.
+     * In the `spreadingMode=SpreadingModes.INFINITY` mode, the `snapScrollToEnd` property is automatically disabled, since the list has no beginning or end.
+     */
+    snapScrollToEnd: _angular_core.InputSignal<boolean>;
+    private _snapScrollToBottomOptions;
+    /**
+     * @deprecated
+     * The stopSnappingScrollToEnd property is deprecated. Use the snapScrollToEnd property.
+     */
+    snapScrollToBottom: _angular_core.InputSignal<boolean>;
+    private _scrollbarEnabledOptions;
+    /**
+     * Determines whether the scrollbar is shown or not. The default value is "true".
+     */
+    scrollbarEnabled: _angular_core.InputSignal<boolean>;
+    private _scrollbarInteractiveOptions;
+    /**
+     * Determines whether scrolling using the scrollbar will be possible. The default value is "true".
+     */
+    scrollbarInteractive: _angular_core.InputSignal<boolean>;
+    private _overlappingScrollbarOptions;
+    /**
+     * Determines whether the scroll bar will overlap the list. The default value is "false".
+     */
+    overlappingScrollbar: _angular_core.InputSignal<boolean>;
+    private _scrollBehaviorOptions;
+    /**
+     * Defines the scrolling behavior for any element on the page. The default value is "smooth".
+     */
+    scrollBehavior: _angular_core.InputSignal<ScrollBehavior>;
+    private _scrollingSettingsOptions;
+    /**
+     * Scrolling settings.
+     * - frictionalForce - Frictional force. Default value is 0.035.
+     * - mass - Mass. Default value is 0.005.
+     * - maxDistance - Maximum scrolling distance. Default value is 100000.
+     * - maxDuration - Maximum animation duration. Default value is 4000.
+     * - speedScale - Speed scale. Default value is 10.
+     * - optimization - Enables scrolling performance optimization. Default value is `true`.
+     */
+    scrollingSettings: _angular_core.InputSignal<IScrollingSettings$1>;
+    private _itemTransformOptions;
+    /**
+     * Custom transformation of element's position, rotation, scale, opacity and zIndex. The default value is `null`.
+     */
+    itemTransform: _angular_core.InputSignal<ItemTransform | null>;
+    private _snapToItemOptions;
+    /**
+     * Snap to an item. The default value is `false`.
+     */
+    snapToItem: _angular_core.InputSignal<boolean>;
+    private _snapToItemAlignOptions;
+    /**
+     * Alignment for snapToItem. Available values ​​are `start`, `center`, and `end`. The default value is `center`.
+     */
+    snapToItemAlign: _angular_core.InputSignal<SnapToItemAlign>;
+    private _snappingDistanceOptions;
+    /**
+     * Snapping activation distance. Can be specified as a percentage of the element size or in absolute values.
+     * The default value is `25%`.
+     */
+    snappingDistance: _angular_core.InputSignal<SnappingDistance>;
+    private _scrollingOneByOneOptions;
+    /**
+     * Specifies whether to scroll one item at a time if true and the scrollToItem property is set. The default value is `false`.
+     */
+    scrollingOneByOne: _angular_core.InputSignal<boolean>;
+    private _alignmentOptions;
+    /**
+     * Determines the alignment of the list. Two modes are available: `none` and `center`. The `center` mode aligns the list items to the center of the viewport, ideal for use with the `itemTransform` property.
+     * The `none` mode means no alignment. The default value is `none`.
+     */
+    alignment: _angular_core.InputSignal<Alignment>;
+    private _zIndexWhenSelectingOptions;
+    /**
+     * Defines the zIndex when a list item is selected. The default value is `null`.
+     */
+    zIndexWhenSelecting: _angular_core.InputSignal<string | null>;
+    private _spreadingModeOptions;
+    /**
+     * The order of list elements. Available values ​​are `standard` and `infinity`.
+     * `normal` — list elements are ordered according to the collection sequence.
+     * `infinity` — list elements are ordered cyclically, forming an infinite list.
+     * When set to `infinity`, the `alignment` property is forced to the value `Alignments.CENTER`, the `scrollbarEnabled` property is forced to the `false`
+     * The default value is `standard`.
+     */
+    spreadingMode: _angular_core.InputSignal<SpreadingMode>;
+    private _dividesOptions;
+    /**
+     * Column or row numbers. The default value is `1`.
+     */
+    divides: _angular_core.InputSignal<number>;
+    private _motionBlurOptions;
+    /**
+     * Motion blur effect. The default value is `0.15`.
+     */
+    motionBlur: _angular_core.InputSignal<number>;
+    private _maxMotionBlurOptions;
+    /**
+     * Maximum motion blur effect. The default value is `0.5`.
+     */
+    maxMotionBlur: _angular_core.InputSignal<number>;
+    private _motionBlurEnabledOptions;
+    /**
+     * Determines whether to apply motion blur or not. The default value is `false`.
+     */
+    motionBlurEnabled: _angular_core.InputSignal<boolean>;
+    private _animationParamsOptions;
+    /**
+     * Animation parameters. The default value is "{ scrollToItem: 150, snapToItem: 150, navigateToItem: 150, navigateByKeyboard: 50 }".
+     */
+    animationParams: _angular_core.InputSignal<IAnimationParams$1>;
+    private _overscrollEnabledOptions;
+    /**
+     * Determines whether the overscroll (re-scroll) feature will work. The default value is "true".
+     */
+    overscrollEnabled: _angular_core.InputSignal<boolean>;
+    private _enabledBufferOptimizationOptions;
+    /**
+     * Experimental!
+     * Enables buffer optimization.
+     * Can only be used if items in the collection are not added or updated. Otherwise, artifacts in the form of twitching of the scroll area are possible.
+     * Works only if the property dynamic = true
+     */
+    enabledBufferOptimization: _angular_core.InputSignal<boolean>;
+    private _itemRendererOptions;
+    /**
+     * Rendering element template.
+     */
+    itemRenderer: _angular_core.InputSignal<TemplateRef<any>>;
+    private _itemRenderer;
+    private _itemConfigMapOptions;
+    /**
+     * Sets `sticky` position, `fullSize`, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied.
+     * If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end.
+     *  Default value is `0`.
+     * `selectable` determines whether an element can be selected or not. Default value is `true`.
+     * `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and
+     *  collapse elements in front that do not have a `sticky` property.
+     * `fullSize` determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true. The default value is false.
+     * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/models/item-config-map.model.ts
+     * @author Evgenii Alexandrovich Grebennikov
+     * @email djonnyx@gmail.com
+     */
+    itemConfigMap: _angular_core.InputSignal<IVirtualListItemConfigMap>;
+    private _itemSizeOptions;
+    /**
+     * If direction = 'vertical', then the height of a typical element. If direction = 'horizontal', then the width of a typical element.
+     * If the `dynamicSize` property is true, the items in the list can have different sizes, and you must specify the `itemSize` property
+     * to adjust the sizes of the items in the unallocated area.
+     * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.
+     */
+    itemSize: _angular_core.InputSignal<number | "viewport">;
+    private _minItemSizeOptions;
+    /**
+     * If the `dynamicSize` property is enabled, the minimum size of the element is set.
+     * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.
+     */
+    minItemSize: _angular_core.InputSignal<number | "viewport">;
+    private _maxItemSizeOptions;
+    /**
+     * If the `dynamicSize` property is enabled, the maximum size of the element is set.
+     * If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size.
+     */
+    maxItemSize: _angular_core.InputSignal<number | "viewport">;
+    private _dynamicSizeOptions;
+    /**
+     * If true, items in the list may have different sizes, and the itemSize property must be specified to adjust
+     * the sizes of items in the unallocated area.
+     * If false then the items in the list have a fixed size specified by the itemSize property. The default value is true.
+     */
+    dynamicSize: _angular_core.InputSignal<boolean>;
+    private _directionOptions;
+    /**
+     * Determines the direction in which elements are placed. Default value is "vertical".
+     */
+    direction: _angular_core.InputSignal<Direction$1>;
+    private _collectionModeOptions;
+    /**
+     * Determines the action modes for collection elements. Default value is "normal".
+     */
+    collectionMode: _angular_core.InputSignal<CollectionMode>;
+    private _bufferSizeOptions;
+    /**
+     * Number of elements outside the scope of visibility. Default value is 2.
+     */
+    bufferSize: _angular_core.InputSignal<number>;
+    private _maxBufferSizeTransform;
+    /**
+     * Maximum number of elements outside the scope of visibility. Default value is 100.
+     * If maxBufferSize is set to be greater than bufferSize, then adaptive buffer mode is enabled.
+     * The greater the scroll size, the more elements are allocated for rendering.
+     */
+    maxBufferSize: _angular_core.InputSignal<number>;
+    private _snappingMethodOptions;
+    /**
+     * Snapping method. Default value is 'standart'.
+     * 'standart' - Classic group visualization.
+     * 'advanced' - A mask is applied to the viewport area so that the background is displayed underneath the attached group.
+     */
+    snappingMethod: _angular_core.InputSignal<SnappingMethod>;
+    private _collapsingModeOptions;
+    /**
+     * Mode for collapsing list items.
+     * `none` - List items are not selectable.
+     * `multi-collapse` - List items are collapsed one by one.
+     * 'accordion' - Accordion collapsible list items.
+     * Default value is `multi-collapse
+     */
+    collapsingMode: _angular_core.InputSignal<CollapsingMode>;
+    private _methodForSelectingOptions;
+    /**
+     * @deprecated
+     * The "methodForSelecting" property is deprecated. Use the "selectMode" property.
+     */
+    methodForSelecting: _angular_core.InputSignal<SelectingMode>;
+    private _selectingModeOptions;
+    /**
+     *  Method for selecting list items. Default value is 'none'.
+     * 'select' - List items are selected one by one.
+     * 'multi-select' - Multiple selection of list items.
+     * 'none' - List items are not selectable.
+     */
+    selectingMode: _angular_core.InputSignal<SelectingMode>;
+    private _trackByOptions;
+    /**
+     * The name of the property by which tracking is performed
+     */
+    trackBy: _angular_core.InputSignal<string>;
+    private _screenReaderMessageOptions;
+    /**
+     * Message for screen reader.
+     * The message format is: "some text $1 some text $2",
+     * where $1 is the number of the first element of the screen collection,
+     * $2 is the number of the last element of the screen collection.
+     */
+    screenReaderMessage: _angular_core.InputSignal<string>;
+    protected readonly screenReaderFormattedMessage: _angular_core.WritableSignal<string>;
+    private _langTextDir;
+    /**
+     * A string indicating the direction of text for the locale.
+     * Can be either "ltr" (left-to-right) or "rtl" (right-to-left).
+     */
+    langTextDir: _angular_core.InputSignal<TextDirection>;
+    private _isSingleSelection;
+    private _isMultiSelection;
+    private _isMultipleCollapse;
+    private _isAccordionCollapse;
+    private _isSnappingMethodAdvanced;
+    protected _isInfinity: Signal<boolean>;
+    private _isVertical;
+    protected get isVertical(): boolean;
+    protected readonly focusedElement: _angular_core.WritableSignal<Id | null>;
+    protected readonly classes: _angular_core.WritableSignal<{
+        [cName: string]: boolean;
+    }>;
+    private _actualItems;
+    private _collapsedItemIds;
+    private _displayComponents;
+    private _snappedDisplayComponents;
+    private _bounds;
+    protected get bounds(): _angular_core.WritableSignal<ISize | null>;
+    protected _actualScrollbarEnabled: Signal<boolean>;
+    private _actualAlignment;
+    protected get actualAlignment(): Signal<Alignment>;
+    private _actualItemSize;
+    protected get actualItemSize(): _angular_core.WritableSignal<number>;
+    private _actualMinItemSize;
+    protected get actualMinItemSize(): _angular_core.WritableSignal<number>;
+    private _actualMaxItemSize;
+    protected get actualMaxItemSize(): _angular_core.WritableSignal<number>;
+    private _totalSize;
+    private _listBounds;
+    private _$scrollSize;
+    private _isScrollStart;
+    private _isScrollEnd;
+    protected _precalculatedScrollStartOffset: _angular_core.WritableSignal<number>;
+    protected _precalculatedScrollEndOffset: _angular_core.WritableSignal<number>;
+    protected _actualScrollStartOffset: _angular_core.WritableSignal<number>;
+    protected _actualScrollEndOffset: _angular_core.WritableSignal<number>;
+    protected _actualSnapScrollToStart: Signal<boolean>;
+    protected _actualSnapScrollToEnd: Signal<boolean>;
+    protected _alignmentScrollStartOffset: _angular_core.WritableSignal<number>;
+    protected _alignmentScrollEndOffset: _angular_core.WritableSignal<number>;
+    private _resizeSnappedComponentHandler;
+    private _resizeSnappedObserver;
+    private focusItem;
+    private _elementRef;
+    /**
+     * Base class of the element component
+     */
+    private _itemComponentClass;
+    protected get itemComponentClass(): Component$1<BaseVirtualListItemComponent>;
+    /**
+     * Base class trackBox
+     */
+    private _trackBoxClass;
+    /**
+     * Dictionary of element sizes by their id
+     */
+    private _trackBox;
+    private _$update;
+    protected readonly $update: rxjs.Observable<string>;
+    private _$scrollTo;
+    protected $scrollTo: rxjs.Observable<IScrollParams>;
+    private _$scrollToExecutor;
+    protected readonly $scrollToExecutor: rxjs.Observable<IScrollParams>;
+    private _$scrollingTo;
+    private _$scroll;
+    readonly $scroll: rxjs.Observable<IScrollEvent$1>;
+    private _$tick;
+    readonly $tick: rxjs.Observable<void>;
+    private _$fireUpdate;
+    protected readonly $fireUpdate: rxjs.Observable<boolean>;
+    private _$fireUpdateNextFrame;
+    protected readonly $fireUpdateNextFrame: rxjs.Observable<boolean>;
+    private _$preventScrollSnapping;
+    protected readonly $preventScrollSnapping: rxjs.Observable<boolean>;
+    private _destroyRef;
+    private _updateId;
+    private _readyForShow;
+    private _cached;
+    private _isLoading;
+    private _animationId;
+    protected get cachable(): boolean;
+    protected get prerenderable(): boolean;
+    private _$viewInit;
+    private readonly $viewInit;
+    private _$destroy;
+    private readonly $destroy;
+    constructor();
+    ngAfterViewInit(): void;
+    private onAfterResize;
+    private checkBoundsOfElements;
+    private snappingHandler;
+    private emitScrollEvent;
+    private getIsSnappingMethodAdvanced;
+    private getIsNoneSelection;
+    private getIsSingleSelection;
+    private getIsMultiSelection;
+    private getIsNoneCollapse;
+    private getIsMultipleCollapse;
+    private getIsAccordionCollapse;
+    private getIsVertical;
+    private getIsLazy;
+    private createDisplayComponentsIfNeed;
+    private updateOffsetsByAllignment;
+    private updateRegularRenderer;
+    /**
+     * Tracking by id
+     */
+    private tracking;
+    private resetBoundsSize;
+    /**
+     * Returns the bounds of an element with a given id
+     */
+    getItemBounds(id: Id): ISize | null;
+    /**
+     * Focus an list item by a given id.
+     */
+    focus(id: Id, align?: FocusAlignment): void;
+    /**
+     * The method scrolls the list to the element with the given `id` and returns the value of the scrolled area.
+     */
+    scrollTo(id: Id, cb?: (() => void) | null, options?: IScrollOptions$1 | null): void;
+    /**
+     * Scrolls the scroll area to the first item in the collection.
+     */
+    scrollToStart(cb?: (() => void) | null, options?: IScrollOptions$1 | null): void;
+    /**
+     * @deprecated
+     * The scrollToEndItem method is deprecated. Use the scrollToEnd method.
+     */
+    scrollToEndItem(cb?: () => void, options?: IScrollOptions$1): void;
+    /**
+     * Scrolls the list to the end of the content size.
+     */
+    scrollToEnd(cb?: (() => void) | null, options?: IScrollOptions$1 | null): void;
+    private scrollToFinalize;
+    protected cleanup(): void;
+    /**
+     * Force clearing the cache.
+     */
+    protected cacheClean(): void;
+    /**
+     * @deprecated
+     * The stopSnappingScrollToEnd method is deprecated. Use the preventSnapping method.
+     */
+    stopSnappingScrollToEnd(): void;
+    /**
+     * Prevents the list from snapping to its start or end edge.
+     */
+    preventSnapping(): void;
+    ngOnDestroy(): void;
+    private dispose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnVirtualListComponent, "cn-virtual-list", never, { "scrollbarThickness": { "alias": "scrollbarThickness"; "required": false; "isSignal": true; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; "isSignal": true; }; "scrollbarThumbRenderer": { "alias": "scrollbarThumbRenderer"; "required": false; "isSignal": true; }; "scrollbarThumbParams": { "alias": "scrollbarThumbParams"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "waitForPreparation": { "alias": "waitForPreparation"; "required": false; "isSignal": true; }; "clickDistance": { "alias": "clickDistance"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "defaultItemValue": { "alias": "defaultItemValue"; "required": false; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "collapsedIds": { "alias": "collapsedIds"; "required": false; "isSignal": true; }; "selectByClick": { "alias": "selectByClick"; "required": false; "isSignal": true; }; "collapseByClick": { "alias": "collapseByClick"; "required": false; "isSignal": true; }; "snap": { "alias": "snap"; "required": false; "isSignal": true; }; "stickyEnabled": { "alias": "stickyEnabled"; "required": false; "isSignal": true; }; "snapToEndTransitionInstantOffset": { "alias": "snapToEndTransitionInstantOffset"; "required": false; "isSignal": true; }; "scrollStartOffset": { "alias": "scrollStartOffset"; "required": false; "isSignal": true; }; "scrollEndOffset": { "alias": "scrollEndOffset"; "required": false; "isSignal": true; }; "snapScrollToStart": { "alias": "snapScrollToStart"; "required": false; "isSignal": true; }; "snapScrollToEnd": { "alias": "snapScrollToEnd"; "required": false; "isSignal": true; }; "snapScrollToBottom": { "alias": "snapScrollToBottom"; "required": false; "isSignal": true; }; "scrollbarEnabled": { "alias": "scrollbarEnabled"; "required": false; "isSignal": true; }; "scrollbarInteractive": { "alias": "scrollbarInteractive"; "required": false; "isSignal": true; }; "overlappingScrollbar": { "alias": "overlappingScrollbar"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; "scrollingSettings": { "alias": "scrollingSettings"; "required": false; "isSignal": true; }; "itemTransform": { "alias": "itemTransform"; "required": false; "isSignal": true; }; "snapToItem": { "alias": "snapToItem"; "required": false; "isSignal": true; }; "snapToItemAlign": { "alias": "snapToItemAlign"; "required": false; "isSignal": true; }; "snappingDistance": { "alias": "snappingDistance"; "required": false; "isSignal": true; }; "scrollingOneByOne": { "alias": "scrollingOneByOne"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "zIndexWhenSelecting": { "alias": "zIndexWhenSelecting"; "required": false; "isSignal": true; }; "spreadingMode": { "alias": "spreadingMode"; "required": false; "isSignal": true; }; "divides": { "alias": "divides"; "required": false; "isSignal": true; }; "motionBlur": { "alias": "motionBlur"; "required": false; "isSignal": true; }; "maxMotionBlur": { "alias": "maxMotionBlur"; "required": false; "isSignal": true; }; "motionBlurEnabled": { "alias": "motionBlurEnabled"; "required": false; "isSignal": true; }; "animationParams": { "alias": "animationParams"; "required": false; "isSignal": true; }; "overscrollEnabled": { "alias": "overscrollEnabled"; "required": false; "isSignal": true; }; "enabledBufferOptimization": { "alias": "enabledBufferOptimization"; "required": false; "isSignal": true; }; "itemRenderer": { "alias": "itemRenderer"; "required": true; "isSignal": true; }; "itemConfigMap": { "alias": "itemConfigMap"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "minItemSize": { "alias": "minItemSize"; "required": false; "isSignal": true; }; "maxItemSize": { "alias": "maxItemSize"; "required": false; "isSignal": true; }; "dynamicSize": { "alias": "dynamicSize"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "collectionMode": { "alias": "collectionMode"; "required": false; "isSignal": true; }; "bufferSize": { "alias": "bufferSize"; "required": false; "isSignal": true; }; "maxBufferSize": { "alias": "maxBufferSize"; "required": false; "isSignal": true; }; "snappingMethod": { "alias": "snappingMethod"; "required": false; "isSignal": true; }; "collapsingMode": { "alias": "collapsingMode"; "required": false; "isSignal": true; }; "methodForSelecting": { "alias": "methodForSelecting"; "required": false; "isSignal": true; }; "selectingMode": { "alias": "selectingMode"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "screenReaderMessage": { "alias": "screenReaderMessage"; "required": false; "isSignal": true; }; "langTextDir": { "alias": "langTextDir"; "required": false; "isSignal": true; }; }, { "onScroll": "onScroll"; "onScrollEnd": "onScrollEnd"; "onViewportChange": "onViewportChange"; "onSnapItem": "onSnapItem"; "onItemClick": "onItemClick"; "onSelect": "onSelect"; "onCollapse": "onCollapse"; "onScrollReachStart": "onScrollReachStart"; "onScrollReachEnd": "onScrollReachEnd"; }, never, never, false, never>;
+}
+
+declare class CnVirtualListItemModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualListItemModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnVirtualListItemModule, [typeof CnVirtualListItemComponent], [typeof i2.CommonModule, typeof CnVirtualClickModule], [typeof CnVirtualListItemComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnVirtualListItemModule>;
+}
+
+/**
+ * IScrollToParams
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-view/interfaces/scroll-to-params.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollToParams$1 {
+    x?: number;
+    y?: number;
+    left?: number;
+    top?: number;
+    snap?: boolean;
+    normalize?: boolean;
+    force?: boolean;
+    blending?: boolean;
+    behavior?: ScrollBehavior;
+    ease?: Easing;
+    fireUpdate?: boolean;
+    userAction?: boolean;
+    duration?: number;
+}
+
+/**
+ * ScrollerDirection
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-view/enums/scroller-direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum ScrollerDirection$1 {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+
+/**
+ * ScrollerDirections
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-view/enums/scroller-directions.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type ScrollerDirections$1 = ScrollerDirection$1 | 'horizontal' | 'vertical';
+
+/**
+ * BaseScrollView
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-view/base/base-scroll-view.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class BaseScrollView$1 {
+    readonly scrollContent: Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly scrollViewport: Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly direction: _angular_core.InputSignal<ScrollerDirections$1>;
+    readonly startOffset: _angular_core.InputSignal<number>;
+    readonly endOffset: _angular_core.InputSignal<number>;
+    readonly alignmentStartOffset: _angular_core.InputSignal<number>;
+    readonly alignmentEndOffset: _angular_core.InputSignal<number>;
+    readonly isInfinity: _angular_core.InputSignal<boolean>;
+    readonly isVertical: Signal<boolean>;
+    readonly grabbing: _angular_core.WritableSignal<boolean>;
+    readonly langTextDir: _angular_core.InputSignal<TextDirection>;
+    protected _inversion: boolean;
+    protected _overscrollEnabled: boolean;
+    protected _$updateScrollBar: Subject<void>;
+    protected $updateScrollBar: rxjs.Observable<void>;
+    get scrollable(): boolean;
+    protected _destroyRef: DestroyRef;
+    protected _isMoving: boolean;
+    get isMoving(): boolean;
+    protected _x: number;
+    set x(v: number);
+    get x(): number;
+    protected _y: number;
+    set y(v: number);
+    get y(): number;
+    protected _actualTotalSize: number;
+    protected _totalSize: number;
+    set totalSize(v: number);
+    get totalSize(): number;
+    protected _startLayoutOffset: number;
+    set startLayoutOffset(v: number);
+    get startLayoutOffset(): number;
+    get actualScrollHeight(): number;
+    get actualScrollWidth(): number;
+    protected _actualX: number;
+    get actualScrollLeft(): number;
+    protected _actualY: number;
+    get actualScrollTop(): number;
+    get scrollLeft(): number;
+    get scrollTop(): number;
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    readonly viewportBounds: _angular_core.WritableSignal<ISize>;
+    readonly contentBounds: _angular_core.WritableSignal<ISize>;
+    protected _isCoordinatesOverrided: boolean;
+    constructor();
+    tick(): void;
+    protected overrideCoordinates(x: number, y: number): void;
+    protected normalizeScrollSize(): boolean;
+    protected onResizeViewport(): void;
+    protected onResizeContent(value?: number | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseScrollView$1, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseScrollView$1, "base-scroll-view", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "startOffset": { "alias": "startOffset"; "required": false; "isSignal": true; }; "endOffset": { "alias": "endOffset"; "required": false; "isSignal": true; }; "alignmentStartOffset": { "alias": "alignmentStartOffset"; "required": false; "isSignal": true; }; "alignmentEndOffset": { "alias": "alignmentEndOffset"; "required": false; "isSignal": true; }; "isInfinity": { "alias": "isInfinity"; "required": false; "isSignal": true; }; "langTextDir": { "alias": "langTextDir"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * ScrollingDirection
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/utils/scrolling-direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class ScrollingDirection {
+    private _length;
+    private _value;
+    private _$direction;
+    readonly $direction: rxjs.Observable<ScrollDirection$1>;
+    constructor(_length?: number);
+    add(v: ScrollDirection$1): void;
+    get(): ScrollDirection$1;
+    clear(): void;
+}
+
+/**
+ * CnScrollView
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-view/cn-scroll-view.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollView$1 extends BaseScrollView$1 {
+    readonly cdkScrollable: CdkScrollable | undefined;
+    protected _service: CnVirtualListService;
+    readonly scrollBehavior: _angular_core.InputSignal<ScrollBehavior>;
+    readonly overscrollEnabled: _angular_core.InputSignal<boolean>;
+    readonly scrollingSettings: _angular_core.InputSignal<IScrollingSettings$1>;
+    readonly snapToItem: _angular_core.InputSignal<boolean>;
+    readonly scrollingOneByOne: _angular_core.InputSignal<boolean>;
+    readonly snapToItemAlign: _angular_core.InputSignal<SnapToItemAlign>;
+    readonly snappingDistance: _angular_core.InputSignal<SnappingDistance>;
+    readonly animationParams: _angular_core.InputSignal<IAnimationParams$1>;
+    protected _normalizeValueFromZero: boolean;
+    protected _isScrollsTo: boolean;
+    protected _scrollDirection: ScrollingDirection;
+    get scrollDirection(): ScrollDirection$1;
+    get $scrollDirection(): rxjs.Observable<ScrollDirection$1>;
+    protected _$wheel: Subject<number>;
+    readonly $wheel: rxjs.Observable<number>;
+    protected _$scroll: Subject<boolean>;
+    readonly $scroll: rxjs.Observable<boolean>;
+    protected _$scrollEnd: Subject<boolean>;
+    readonly $scrollEnd: rxjs.Observable<boolean>;
+    protected _velocities: Array<number>;
+    protected _$velocity: BehaviorSubject<number>;
+    protected $velocity: rxjs.Observable<number>;
+    get velocity(): number;
+    protected _$averageVelocity: BehaviorSubject<number>;
+    protected $averageVelocity: rxjs.Observable<number>;
+    get averageVelocity(): number;
+    private _measureVelocityTimestamp;
+    private _measureVelocityLastPosition;
+    private _startPositionX;
+    private _startPositionY;
+    private _touchId;
+    set startPosition(v: number);
+    get startPosition(): number;
+    protected _animator: Animator;
+    protected _interactive: boolean;
+    protected _horizontalAxisInvertion: Signal<boolean>;
+    get inverted(): boolean;
+    private _overscrollIteration;
+    private _overscrollStartIteration;
+    private _overscrollApplied;
+    set x(v: number);
+    get x(): number;
+    protected setX(x: number, snap?: boolean, normalize?: boolean): void;
+    set y(v: number);
+    get y(): number;
+    protected setY(y: number, snap?: boolean, normalize?: boolean): void;
+    protected _delta: number;
+    set delta(v: number);
+    set startLayoutOffset(v: number);
+    get startLayoutOffset(): number;
+    private _scrollDirectionValueX;
+    private _scrollDirectionValueY;
+    protected _intersectionComponentId: Id | null;
+    protected _isAlignmentAnimation: boolean;
+    get animated(): boolean;
+    constructor();
+    hasAnimation(id?: number): boolean;
+    protected updateDirection(position: number, prePosition: number): void;
+    protected overrideCoordinates(x: number, y: number): void;
+    protected measureVelocity(): void;
+    protected stopMoving(): void;
+    private snapIfNecessary;
+    protected snapWithInitialForceIfNecessary(v0?: number | null, animated?: boolean, force?: boolean, fireUpdate?: boolean): boolean;
+    private calculatePosition;
+    private cancelOverscroll;
+    private checkOverscrollByAxis;
+    private checkOverscroll;
+    private calculateVelocity;
+    private calculateAcceleration;
+    stopScrolling(force?: boolean): void;
+    protected move(isVertical: boolean, position: number, blending?: boolean, userAction?: boolean, fireUpdate?: boolean): void;
+    protected moveWithAcceleration(isVertical: boolean, position: number, v0: number, v: number, a0: number, timestamp: number): void;
+    protected normalizeValue(value: number): number;
+    protected animate(startValue: number, endValue: number, duration?: number, easingFunction?: Easing, blending?: boolean, userAction?: boolean, alignmentAtComplete?: boolean, skipOverridedCoordinates?: boolean, fireUpdate?: boolean): number;
+    protected getSnappedComponentSize(): number | null;
+    protected alignPosition(animated?: boolean, force?: boolean, fireUpdate?: boolean): boolean;
+    protected checkIntersectionComponent(): void;
+    protected onAnimationComplete(position: number): void;
+    fireScroll(userAction?: boolean): void;
+    scrollLimits(value?: number | undefined, silent?: boolean): boolean;
+    scroll(params: IScrollToParams$1): number;
+    protected emitScrollableEvent(): void;
+    refreshCoordinate(x: number, y: number): void;
+    protected fireScrollEvent(userAction: boolean): void;
+    protected onDragStart(): void;
+    reset(offset?: number): void;
+    stopAnimation(id: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollView$1, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnScrollView$1, "cn-scroll-view", never, { "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; "overscrollEnabled": { "alias": "overscrollEnabled"; "required": false; "isSignal": true; }; "scrollingSettings": { "alias": "scrollingSettings"; "required": false; "isSignal": true; }; "snapToItem": { "alias": "snapToItem"; "required": false; "isSignal": true; }; "scrollingOneByOne": { "alias": "scrollingOneByOne"; "required": false; "isSignal": true; }; "snapToItemAlign": { "alias": "snapToItemAlign"; "required": false; "isSignal": true; }; "snappingDistance": { "alias": "snappingDistance"; "required": false; "isSignal": true; }; "animationParams": { "alias": "animationParams"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * IScrollBarDragEvent
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/ng-scroll-bar/interfaces/scrollbar-drag-data.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollBarDragEvent$1 {
+    position: number;
+    min: number;
+    max: number;
+    userAction: boolean;
+    animation: boolean;
+}
+
+interface IScrollBarTemplateContext$1 {
+    /**
+     * API provider
+     */
+    api: CnScrollBarPublicService$1;
+    /**
+     * Scrollbar thumb width.
+     */
+    width: number;
+    /**
+     * Scrollbar thumb height.
+     */
+    height: number;
+    /**
+     * Gradient fill position parameters.
+     */
+    fillPositions: GradientColorPositions;
+    /**
+     * Additional options for the scrollbar.
+     */
+    params: {
+        [propName: string]: any;
+    };
+}
+
+/**
+ * CnScrollBarService
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-bar/cn-scroll-bar.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollBarService$1 {
+    private _$click;
+    readonly $click: rxjs.Observable<PointerEvent | MouseEvent>;
+    private _$state;
+    readonly $state: rxjs.Observable<ScrollbarStates$1>;
+    set state(v: ScrollbarState$1);
+    get state(): ScrollbarState$1;
+    click(event: PointerEvent | MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarService$1, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CnScrollBarService$1>;
+}
+
+/**
+ * ScrollBar component.
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroll-bar/cn-scroll-bar.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollBarComponent$1 extends CnScrollView$1 {
+    protected _defaultRenderer: Signal<TemplateRef<any> | undefined>;
+    protected _scrollBarService: CnScrollBarService$1;
+    private _apiService;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly onDrag: _angular_core.OutputEmitterRef<IScrollBarDragEvent$1>;
+    readonly onDragEnd: _angular_core.OutputEmitterRef<IScrollBarDragEvent$1>;
+    readonly thumbGradientPositions: _angular_core.InputSignal<GradientColorPositions>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly thickness: _angular_core.InputSignal<number>;
+    readonly scrollbarMinSize: _angular_core.InputSignal<number>;
+    readonly prepared: _angular_core.InputSignal<boolean>;
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    readonly overlapping: _angular_core.InputSignal<boolean>;
+    readonly show: _angular_core.InputSignal<boolean>;
+    readonly params: _angular_core.InputSignal<{
+        [propName: string]: any;
+    } | null>;
+    readonly renderer: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly thumbRenderer: _angular_core.WritableSignal<TemplateRef<any> | null>;
+    protected readonly hoverState: _angular_core.WritableSignal<boolean>;
+    protected readonly pressedState: _angular_core.WritableSignal<boolean>;
+    protected readonly templateContext: Signal<IScrollBarTemplateContext$1>;
+    protected readonly styles: Signal<{
+        [sName: string]: any;
+    }>;
+    protected readonly thumbWidth: Signal<number>;
+    protected readonly thumbHeight: Signal<number>;
+    private _$scrollingCancel;
+    protected readonly $scrollingCancel: rxjs.Observable<void>;
+    private _elementRef;
+    constructor();
+    private createDragEvent;
+    private thumbHit;
+    click(event: PointerEvent | MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarComponent$1, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnScrollBarComponent$1, "cn-scroll-bar", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "thumbGradientPositions": { "alias": "thumbGradientPositions"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; "isSignal": true; }; "prepared": { "alias": "prepared"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "overlapping": { "alias": "overlapping"; "required": false; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "renderer": { "alias": "renderer"; "required": false; "isSignal": true; }; }, { "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; }, never, never, false, never>;
+}
+
+/**
+ * The scroller for the CnVirtualList item component
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-scroller/cn-scroller.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollerComponent$1 extends CnScrollView$1 {
+    readonly scrollBar: CnScrollBarComponent$1 | undefined;
+    readonly filter: Signal<ElementRef<SVGFEGaussianBlurElement> | undefined>;
+    readonly onScrollbarVisible: _angular_core.OutputEmitterRef<boolean>;
+    readonly scrollbarEnabled: _angular_core.InputSignal<boolean>;
+    readonly scrollbarInteractive: _angular_core.InputSignal<boolean>;
+    readonly focusedElement: _angular_core.InputSignal<Id | null>;
+    readonly overlappingScrollbar: _angular_core.InputSignal<boolean>;
+    readonly content: _angular_core.InputSignal<HTMLElement | undefined>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly classes: _angular_core.InputSignal<{
+        [cName: string]: boolean;
+    }>;
+    readonly scrollbarMinSize: _angular_core.InputSignal<number>;
+    readonly scrollbarThickness: _angular_core.InputSignal<number>;
+    readonly scrollbarThumbRenderer: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly scrollbarThumbParams: _angular_core.InputSignal<{
+        [propName: string]: any;
+    } | null>;
+    readonly motionBlur: _angular_core.InputSignal<number | "disabled">;
+    readonly maxMotionBlur: _angular_core.InputSignal<number>;
+    readonly motionBlurEnabled: _angular_core.InputSignal<boolean>;
+    readonly actualClasses: Signal<{
+        [cName: string]: boolean;
+    }>;
+    readonly containerClasses: Signal<{
+        [cName: string]: boolean;
+    }>;
+    readonly thumbGradientPositions: _angular_core.WritableSignal<GradientColorPositions>;
+    readonly thumbSize: _angular_core.WritableSignal<number>;
+    readonly scrollbarShow: _angular_core.WritableSignal<boolean>;
+    readonly preparedSignal: _angular_core.WritableSignal<boolean>;
+    readonly listStyles: _angular_core.WritableSignal<{
+        perspectiveOrigin: string;
+    }>;
+    private _scrollBox;
+    get host(): HTMLDivElement | undefined;
+    private _$scrollbarScroll;
+    readonly $scrollbarScroll: rxjs.Observable<boolean>;
+    private _prepared;
+    set prepared(v: boolean);
+    protected setX(x: number, snap?: boolean, normalize?: boolean): void;
+    protected setY(y: number, snap?: boolean, normalize?: boolean): void;
+    set startLayoutOffset(v: number);
+    get startLayoutOffset(): number;
+    readonly viewInitialized: _angular_core.WritableSignal<boolean>;
+    private _isScrollbarUserAction;
+    get isScrollbarUserAction(): boolean;
+    protected _$resizeViewport: Subject<ISize>;
+    readonly $resizeViewport: rxjs.Observable<ISize>;
+    protected _$resizeContent: Subject<ISize>;
+    readonly $resizeContent: rxjs.Observable<ISize>;
+    protected _filterId: string;
+    protected _filter: string;
+    constructor();
+    private recalculatePerspective;
+    protected onResizeViewport(): void;
+    protected onResizeContent(value?: number | null): void;
+    private updateScrollBarHandler;
+    ngAfterViewInit(): void;
+    tick(): void;
+    private updateScrollBar;
+    refreshScrollbar(): void;
+    protected onDragStart(): void;
+    reset(): void;
+    refresh(fireUpdate?: boolean, updateScrollbar?: boolean): void;
+    snapIfNeed(animated?: boolean, fireUpdate?: boolean): void;
+    startScrollTo(): void;
+    finishedScrollTo(): void;
+    scrollTo(params: IScrollToParams$1): number;
+    stopScrollbar(): void;
+    private dropVelocity;
+    protected stopMoving(): void;
+    protected onAnimationComplete(position: number): void;
+    onScrollBarDragHandler(event: IScrollBarDragEvent$1): void;
+    onScrollBarDragEndHandler(event: IScrollBarDragEvent$1): void;
+    private fireUpdateIfEdgesDetected;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollerComponent$1, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnScrollerComponent$1, "cn-scroller", never, { "scrollbarEnabled": { "alias": "scrollbarEnabled"; "required": false; "isSignal": true; }; "scrollbarInteractive": { "alias": "scrollbarInteractive"; "required": false; "isSignal": true; }; "focusedElement": { "alias": "focusedElement"; "required": false; "isSignal": true; }; "overlappingScrollbar": { "alias": "overlappingScrollbar"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; "isSignal": true; }; "scrollbarThickness": { "alias": "scrollbarThickness"; "required": false; "isSignal": true; }; "scrollbarThumbRenderer": { "alias": "scrollbarThumbRenderer"; "required": false; "isSignal": true; }; "scrollbarThumbParams": { "alias": "scrollbarThumbParams"; "required": false; "isSignal": true; }; "motionBlur": { "alias": "motionBlur"; "required": false; "isSignal": true; }; "maxMotionBlur": { "alias": "maxMotionBlur"; "required": false; "isSignal": true; }; "motionBlurEnabled": { "alias": "motionBlurEnabled"; "required": false; "isSignal": true; }; }, { "onScrollbarVisible": "onScrollbarVisible"; }, never, ["*"], false, never>;
+}
+
+declare class CnScrollBarModule$1 {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarModule$1, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnScrollBarModule$1, [typeof CnScrollBarComponent$1], [typeof i2.CommonModule], [typeof CnScrollBarComponent$1]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnScrollBarModule$1>;
+}
+
+declare class CnScrollerModule$1 {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollerModule$1, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnScrollerModule$1, [typeof CnScrollerComponent$1], [typeof i2.CommonModule, typeof CnScrollBarModule$1, typeof CnLocaleSensitiveModule, typeof i5.CdkScrollableModule], [typeof CnScrollerComponent$1]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnScrollerModule$1>;
+}
+
+/**
+ * CnPrerenderContainer
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-prerender-container/cn-prerender-container.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnPrerenderContainer {
+    private _list;
+    enabled: _angular_core.InputSignal<boolean>;
+    direction: _angular_core.InputSignal<Direction$1>;
+    isVertical: _angular_core.InputSignal<boolean>;
+    scrollbarEnabled: _angular_core.InputSignal<boolean>;
+    startOffset: _angular_core.InputSignal<number>;
+    endOffset: _angular_core.InputSignal<number>;
+    bounds: _angular_core.InputSignal<ISize>;
+    dynamic: _angular_core.InputSignal<boolean>;
+    itemSize: _angular_core.InputSignal<number>;
+    trackBy: _angular_core.InputSignal<string>;
+    divides: _angular_core.InputSignal<number>;
+    itemRenderer: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    readonly $render: Observable<PrerenderCache>;
+    get active(): boolean;
+    constructor();
+    clear(): void;
+    on(items?: IVirtualListCollection | null): void;
+    off(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnPrerenderContainer, "cn-prerender-container", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "isVertical": { "alias": "isVertical"; "required": false; "isSignal": true; }; "scrollbarEnabled": { "alias": "scrollbarEnabled"; "required": false; "isSignal": true; }; "startOffset": { "alias": "startOffset"; "required": false; "isSignal": true; }; "endOffset": { "alias": "endOffset"; "required": false; "isSignal": true; }; "bounds": { "alias": "bounds"; "required": true; "isSignal": true; }; "dynamic": { "alias": "dynamic"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "divides": { "alias": "divides"; "required": false; "isSignal": true; }; "itemRenderer": { "alias": "itemRenderer"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * CnPrerenderList
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-prerender-container/components/cn-prerender-list/cn-prerender-list.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnPrerenderList implements OnDestroy {
+    private _listContainerRef;
+    enabled: _angular_core.InputSignal<boolean>;
+    direction: _angular_core.InputSignal<Direction$1>;
+    isVertical: _angular_core.InputSignal<boolean>;
+    scrollbarEnabled: _angular_core.InputSignal<boolean>;
+    startOffset: _angular_core.InputSignal<number>;
+    endOffset: _angular_core.InputSignal<number>;
+    bounds: _angular_core.InputSignal<ISize>;
+    dynamic: _angular_core.InputSignal<boolean>;
+    itemSize: _angular_core.InputSignal<number>;
+    trackBy: _angular_core.InputSignal<string>;
+    divides: _angular_core.InputSignal<number>;
+    itemRenderer: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    itemComponentClass: _angular_core.InputSignal<Component$1<BaseVirtualListItemComponent>>;
+    protected _items: _angular_core.WritableSignal<IVirtualListCollection<Object> | null>;
+    protected readonly classes: _angular_core.WritableSignal<{
+        [cName: string]: boolean;
+    }>;
+    private _$render;
+    $render: Observable<PrerenderCache>;
+    private _$componentResize;
+    protected $componentResize: Observable<PrerenderCache>;
+    private _trackBox;
+    private _onTrackBoxResizeHandler;
+    private _elementRef;
+    protected $isVertical: Observable<boolean>;
+    protected $items: Observable<IVirtualListCollection | null>;
+    protected $bounds: Observable<ISize>;
+    get active(): boolean;
+    private _activated;
+    private _subscriptions;
+    private _destroyRef;
+    constructor();
+    activate(): void;
+    deactivate(): void;
+    clear(): void;
+    on(items?: IVirtualListCollection | null): void;
+    off(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    dispose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnPrerenderList, "cn-prerender-list", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "isVertical": { "alias": "isVertical"; "required": false; "isSignal": true; }; "scrollbarEnabled": { "alias": "scrollbarEnabled"; "required": false; "isSignal": true; }; "startOffset": { "alias": "startOffset"; "required": false; "isSignal": true; }; "endOffset": { "alias": "endOffset"; "required": false; "isSignal": true; }; "bounds": { "alias": "bounds"; "required": true; "isSignal": true; }; "dynamic": { "alias": "dynamic"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "divides": { "alias": "divides"; "required": false; "isSignal": true; }; "itemRenderer": { "alias": "itemRenderer"; "required": false; "isSignal": true; }; "itemComponentClass": { "alias": "itemComponentClass"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * CnPrerenderVirtualListItemComponent
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-prerender-container/components/cn-prerender-list-item/cn-prerender-list-item.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnPrerenderVirtualListItemComponent extends CnVirtualListItemComponent {
+    protected update(): void;
+    show(): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderVirtualListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnPrerenderVirtualListItemComponent, "cn-prerender-virtual-list-item", never, {}, {}, never, never, false, never>;
+}
+
+declare class CnPrerenderVirtualListItemModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderVirtualListItemModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnPrerenderVirtualListItemModule, [typeof CnPrerenderVirtualListItemComponent], [typeof i2.CommonModule, typeof CnVirtualClickModule], [typeof CnPrerenderVirtualListItemComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnPrerenderVirtualListItemModule>;
+}
+
+/**
+ * CnPrerenderScrollerComponent
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/list/components/cn-prerender-container/components/cn-prerender-scroller/cn-prerender-scroller.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnPrerenderScrollerComponent extends BaseScrollView$1 {
+    scrollBar: CnScrollBarComponent$1 | undefined;
+    scrollbarEnabled: _angular_core.InputSignal<boolean>;
+    classes: _angular_core.InputSignal<{
+        [cName: string]: boolean;
+    }>;
+    actualClasses: Signal<{
+        [cName: string]: boolean;
+    }>;
+    containerClasses: _angular_core.WritableSignal<{
+        [cName: string]: boolean;
+    }>;
+    thumbSize: _angular_core.WritableSignal<number>;
+    scrollbarShow: _angular_core.WritableSignal<boolean>;
+    set x(v: number);
+    get x(): number;
+    set y(v: number);
+    get y(): number;
+    protected onResizeViewport(): void;
+    protected onResizeContent(): void;
+    private _scrollBox;
+    constructor();
+    private updateScrollBarHandler;
+    protected updateScrollBar(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderScrollerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnPrerenderScrollerComponent, "cn-prerender-scroller", never, { "scrollbarEnabled": { "alias": "scrollbarEnabled"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class CnPrerenderScrollerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderScrollerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnPrerenderScrollerModule, [typeof CnPrerenderScrollerComponent], [typeof i2.CommonModule, typeof CnLocaleSensitiveModule], [typeof CnPrerenderScrollerComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnPrerenderScrollerModule>;
+}
+
+declare class CnPrerenderListModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderListModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnPrerenderListModule, [typeof CnPrerenderList], [typeof i2.CommonModule, typeof CnPrerenderVirtualListItemModule, typeof CnPrerenderScrollerModule], [typeof CnPrerenderList]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnPrerenderListModule>;
+}
+
+declare class CnPrerenderContainerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnPrerenderContainerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnPrerenderContainerModule, [typeof CnPrerenderContainer], [typeof i2.CommonModule, typeof CnPrerenderListModule], [typeof CnPrerenderContainer]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnPrerenderContainerModule>;
+}
+
+declare class CnVirtualListModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualListModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnVirtualListModule, [typeof CnVirtualListComponent], [typeof i2.CommonModule, typeof CnVirtualListItemModule, typeof CnScrollerModule$1, typeof CnPrerenderContainerModule, typeof CnLocaleSensitiveModule], [typeof CnVirtualListComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnVirtualListModule>;
+}
+
+/**
+ * IScrollToParams
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-view/interfaces/scroll-to-params.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollToParams {
+    x?: number | null;
+    y?: number | null;
+    left?: number | null;
+    top?: number | null;
+    normalize?: boolean;
+    force?: boolean;
+    blending?: boolean;
+    behavior?: ScrollBehavior;
+    ease?: Easing;
+    fireUpdate?: boolean;
+    userAction?: boolean;
+    duration?: number;
+}
+
+/**
+ * ScrollerDirection
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-view/enums/scroller-direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum ScrollerDirection {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical",
+    BOTH = "both"
+}
+
+/**
+ * ScrollerDirections
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-view/enums/scroller-directions.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type ScrollerDirections = ScrollerDirection | 'horizontal' | 'vertical' | 'both';
+
+/**
+ * BaseScrollView
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-view/base/base-scroll-view.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class BaseScrollView {
+    readonly scrollContent: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly scrollViewport: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly direction: _angular_core.InputSignal<ScrollerDirections>;
+    readonly langTextDir: _angular_core.InputSignal<TextDirection>;
+    readonly leftOffset: _angular_core.InputSignal<number>;
+    readonly topOffset: _angular_core.InputSignal<number>;
+    readonly rightOffset: _angular_core.InputSignal<number>;
+    readonly bottomOffset: _angular_core.InputSignal<number>;
+    readonly grabbing: _angular_core.WritableSignal<boolean>;
+    protected _inversion: boolean;
+    protected _overscrollEnabled: boolean;
+    protected _$updateScrollBarHorizontal: Subject<void>;
+    protected $updateScrollBarHorizontal: rxjs.Observable<void>;
+    protected _$updateScrollBarVertical: Subject<void>;
+    protected $updateScrollBarVertical: rxjs.Observable<void>;
+    get scrollableX(): boolean;
+    get scrollableY(): boolean;
+    protected _destroyRef: DestroyRef;
+    protected _service: IScrollViewService;
+    protected _isMoving: boolean;
+    get isMoving(): boolean;
+    protected _x: number;
+    set x(v: number);
+    get x(): number;
+    protected _y: number;
+    set y(v: number);
+    get y(): number;
+    protected _actualTotalWidth: number;
+    protected _totalWidth: number;
+    set totalWidth(v: number);
+    get totalWidth(): number;
+    protected _actualTotalHeight: number;
+    protected _totalHeight: number;
+    set totalHeight(v: number);
+    get totalHeight(): number;
+    protected _startLayoutOffsetX: number;
+    set startLayoutOffsetX(v: number);
+    get startLayoutOffsetX(): number;
+    protected _startLayoutOffsetY: number;
+    set startLayoutOffsetY(v: number);
+    get startLayoutOffsetY(): number;
+    get actualScrollHeight(): number;
+    get actualScrollWidth(): number;
+    protected _actualX: number;
+    get actualScrollLeft(): number;
+    protected _actualY: number;
+    get actualScrollTop(): number;
+    get scrollLeft(): number;
+    get scrollTop(): number;
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    readonly viewportBounds: _angular_core.WritableSignal<ISize>;
+    readonly contentBounds: _angular_core.WritableSignal<ISize>;
+    tick(): void;
+    protected overrideCoordinates(x: number, y: number): void;
+    protected normalizeScrollWidth(): boolean;
+    protected normalizeScrollHeight(): boolean;
+    protected normalizeScrollSize(): void;
+    protected onResizeViewport(): void;
+    protected onResizeContent(valueWidth?: number | null, valueHeight?: number | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseScrollView, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseScrollView, "base-scroll-view", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "langTextDir": { "alias": "langTextDir"; "required": false; "isSignal": true; }; "leftOffset": { "alias": "leftOffset"; "required": false; "isSignal": true; }; "topOffset": { "alias": "topOffset"; "required": false; "isSignal": true; }; "rightOffset": { "alias": "rightOffset"; "required": false; "isSignal": true; }; "bottomOffset": { "alias": "bottomOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * IAnimationParams
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/interfaces/animation-params.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IAnimationParams {
+    scrollToItem: number;
+}
+
+/**
+ * A value of -1 indicates the direction is up or left (if the list direction is horizontal).
+ * A value of 1 indicates the direction is down or right (if the list direction is horizontal).
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/types/scroll-direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type ScrollDirection = -1 | 1 | 0;
+
+/**
+ * Axis of the arrangement of virtual list elements.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/enums/directions.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare enum Directions {
+    /**
+     * Horizontal axis.
+     */
+    HORIZONTAL = "horizontal",
+    /**
+     * Vertical axis.
+     */
+    VERTICAL = "vertical",
+    /**
+     * Horizontal and vertical axes.
+     */
+    BOTH = "both"
+}
+
+/**
+ * Axis of the arrangement of virtual list elements.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/enums/direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+type Direction = Directions | 'horizontal' | 'vertical' | 'both';
+
+/**
+ * Interface IScrollEvent.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/interfaces/scroll-event.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollEvent {
+    /**
+     * Scroll area width
+     */
+    scrollWidth: number;
+    /**
+     * Scroll area height
+     */
+    scrollHeight: number;
+    /**
+     * Viewport width
+     */
+    viewportWidth: number;
+    /**
+     * Viewport height
+     */
+    viewportHeight: number;
+    /**
+     * The scroller orientation.
+     */
+    scrollerDirection: Direction;
+    /**
+     * A value of -1 indicates the direction is up or left (if the list direction is horizontal).
+     * A value of 1 indicates the direction is down or right (if the list direction is horizontal).
+     */
+    directionX: ScrollDirection;
+    /**
+     * A value of -1 indicates the direction is up or left (if the list direction is horizontal).
+     * A value of 1 indicates the direction is down or right (if the list direction is horizontal).
+     */
+    directionY: ScrollDirection;
+    /**
+     * If true then indicates that the list has been scrolled to the left side.
+     */
+    isLeft: boolean;
+    /**
+     * If true then indicates that the list has been scrolled to the right side.
+     */
+    isRight: boolean;
+    /**
+     * If true then indicates that the list has been scrolled to the top side.
+     */
+    isTop: boolean;
+    /**
+     * If true then indicates that the list has been scrolled to the bottom side.
+     */
+    isBottom: boolean;
+    /**
+     * Has user action
+     */
+    userAction: boolean;
+}
+
+/**
+ * Interface IScrollOptions.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/interfaces/scroll-options.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollOptions {
+    x?: number | null;
+    y?: number | null;
+    left?: number | null;
+    top?: number | null;
+    blending?: boolean;
+    behavior?: ScrollBehavior;
+    ease?: Easing;
+    duration?: number;
+}
+
+/**
+ * Interface IScrollingSettings.
+ * - frictionalForce - Frictional force. Default value is `0.035`.
+ * - mass - Mass. Default value is `0.005`.
+ * - maxDistance - Maximum scrolling distance. Default value is `12500`.
+ * - maxDuration - Maximum animation duration. Default value is `4000`.
+ * - speedScale - Speed scale. Default value is `15`.
+ * - optimization - Enables scrolling performance optimization. Default value is `true`.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/interfaces/scrolling-settings.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollingSettings {
+    /**
+     * Frictional force. Default value is `0.035`.
+     */
+    frictionalForce?: number;
+    /**
+     * Maximum animation duration. Default value is `4000`.
+     */
+    maxDuration?: number;
+    /**
+     * Mass. Default value is `0.005`.
+     */
+    mass?: number;
+    /**
+     * Maximum scrolling distance. Default value is `12500`.
+     */
+    maxDistance?: number;
+    /**
+     * Speed scale. Default value is `15`.
+     */
+    speedScale?: number;
+    /**
+     * Enables scrolling performance optimization. Default value is `true`.
+     */
+    optimization?: boolean;
+}
+
+/**
+ * IScrollViewService
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/interfaces/scroll-view-service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollViewService {
+    get id(): number;
+    initialize: (id: number) => void;
+    animationParams: IAnimationParams;
+    direction: Direction;
+    scrollLeftOffset: number;
+    scrollRightOffset: number;
+    scrollTopOffset: number;
+    scrollBottomOffset: number;
+    snapScrollToLeft: boolean;
+    snapScrollToRight: boolean;
+    snapScrollToTop: boolean;
+    snapScrollToBottom: boolean;
+    get scrollBarSize(): number;
+    set scrollBarSize(v: number);
+    readonly $scrollBarSize: Observable<number>;
+    readonly $langTextDir: Observable<TextDirection>;
+    get langTextDir(): TextDirection;
+    set langTextDir(v: TextDirection);
+    readonly $clickDistance: Observable<number>;
+    get clickDistance(): number;
+    set clickDistance(v: number);
+    readonly $grabbing: Observable<boolean>;
+    get grabbing(): boolean;
+    set grabbing(v: boolean);
+    readonly $tick: Observable<void>;
+    getComponentBoundsByIntersectionPosition: (positionX: number, positionY: number, maxPositionX?: number | null, maxPositionY?: number | null) => (IRect & {
+        id: Id | null;
+        isFirst: boolean;
+        isLast: boolean;
+    }) | null;
+    setIntersectionElementBySnapToItemAlign: (id: Id | null) => void;
+    update: (immediately?: boolean) => void;
+    scrollToLeft: (options?: IScrollOptions) => void;
+    scrollToRight: (options?: IScrollOptions) => void;
+    scrollToTop: (options?: IScrollOptions) => void;
+    scrollToBottom: (options?: IScrollOptions) => void;
+}
+
+/**
+ * IWheelEvent
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-view/interfaces/wheel-event.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IWheelEvent {
+    deltaX: number;
+    deltaY: number;
+}
+
+/**
+ * CnScrollView
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-view/cn-scroll-view.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollView extends BaseScrollView {
+    readonly cdkScrollable: CdkScrollable | undefined;
+    readonly scrollable: _angular_core.InputSignal<boolean>;
+    readonly scrollBehavior: _angular_core.InputSignal<ScrollBehavior>;
+    readonly overscrollEnabled: _angular_core.InputSignal<boolean>;
+    readonly scrollingSettings: _angular_core.InputSignal<IScrollingSettings>;
+    readonly animationParams: _angular_core.InputSignal<IAnimationParams>;
+    protected _normalizeValueFromZero: boolean;
+    protected _isScrollsTo: boolean;
+    private _scrollDirectionValueX;
+    private _scrollDirectionValueY;
+    private _$scrollDirectionX;
+    readonly $scrollDirectionX: rxjs.Observable<ScrollDirection>;
+    set scrollDirectionX(v: ScrollDirection);
+    get scrollDirectionX(): ScrollDirection;
+    private _$scrollDirectionY;
+    readonly $scrollDirectionY: rxjs.Observable<ScrollDirection>;
+    set scrollDirectionY(v: ScrollDirection);
+    get scrollDirectionY(): ScrollDirection;
+    protected _$wheel: Subject<IWheelEvent>;
+    readonly $wheel: rxjs.Observable<IWheelEvent>;
+    protected _$scroll: Subject<boolean>;
+    readonly $scroll: rxjs.Observable<boolean>;
+    protected _$scrollEnd: Subject<boolean>;
+    readonly $scrollEnd: rxjs.Observable<boolean>;
+    protected _velocitiesX: Array<number>;
+    protected _velocitiesY: Array<number>;
+    protected _$velocityX: BehaviorSubject<number>;
+    protected $velocityX: rxjs.Observable<number>;
+    get velocityX(): number;
+    protected _$velocityY: BehaviorSubject<number>;
+    protected $velocityY: rxjs.Observable<number>;
+    get velocityY(): number;
+    protected _$averageVelocityX: BehaviorSubject<number>;
+    protected $averageVelocityX: rxjs.Observable<number>;
+    get averageVelocityX(): number;
+    protected _$averageVelocityY: BehaviorSubject<number>;
+    protected $averageVelocityY: rxjs.Observable<number>;
+    get averageVelocityY(): number;
+    private _measureVelocityTimestampX;
+    private _measureVelocityTimestampY;
+    private _measureVelocityLastPositionX;
+    private _measureVelocityLastPositionY;
+    private _startPositionX;
+    private _startPositionY;
+    private _touchId;
+    protected _animatorX: Animator;
+    protected _animatorY: Animator;
+    protected _interactive: boolean;
+    private _overscrollIteration;
+    set x(v: number);
+    get x(): number;
+    protected setX(x: number, normalize?: boolean): void;
+    set y(v: number);
+    get y(): number;
+    protected setY(y: number, normalize?: boolean): void;
+    protected _deltaX: number;
+    set deltaX(v: number);
+    protected _deltaY: number;
+    set deltaY(v: number);
+    set startLayoutOffsetX(v: number);
+    get startLayoutOffsetX(): number;
+    set startLayoutOffsetY(v: number);
+    get startLayoutOffsetY(): number;
+    protected _intersectionComponentId: Id | null;
+    get animatedX(): boolean;
+    get animatedY(): boolean;
+    get animated(): boolean;
+    protected _horizontalAxisInvertion: Signal<boolean>;
+    protected _horizontalAxisEnabled: Signal<boolean>;
+    protected _verticalAxisEnabled: Signal<boolean>;
+    protected _horizontalScrollRatio: number;
+    get horizontalScrollRatio(): number;
+    protected _verticalScrollRatio: number;
+    get verticalScrollRatio(): number;
+    constructor();
+    hasAnimationX(...ids: Array<number>): boolean;
+    hasAnimationY(...ids: Array<number>): boolean;
+    hasAnimation(...ids: Array<number>): boolean;
+    protected updateDirectionX(position: number, prePosition: number): void;
+    protected updateDirectionY(position: number, prePosition: number): void;
+    protected overrideCoordinates(x: number, y: number): void;
+    protected measureVelocity(): void;
+    protected stopMoving(): void;
+    private calculatePosition;
+    private cancelOverscroll;
+    private checkOverscrollByAxis;
+    private _overscrollXIteration;
+    private _overscrollYIteration;
+    private checkOverscroll;
+    private calculateVelocity;
+    private calculateAcceleration;
+    stopScrolling(): void;
+    protected move(x: number | null, y: number | null, blending?: boolean, userAction?: boolean, fireUpdate?: boolean): void;
+    private calculateParamsWithVelocity;
+    protected moveWithAcceleration(positionX: number, vX: number, a0X: number, timestampX: number, positionY: number, vY: number, a0Y: number, timestampY: number): void;
+    protected normalizeValueX(value: number): number;
+    protected normalizeValueY(value: number): number;
+    protected animate(axis: 'x' | 'y', startValue: number, endValue: number, duration?: number, easingFunction?: Easing, blending?: boolean, userAction?: boolean): number;
+    protected normalizeScrollWidth(): boolean;
+    protected normalizeScrollHeight(): boolean;
+    protected onAnimationComplete(position: number): void;
+    fireScroll(userAction?: boolean): void;
+    scrollLimits(value?: number | undefined, silent?: boolean): boolean;
+    scroll(params: IScrollToParams): Array<number> | null;
+    protected emitScrollableEvent(): void;
+    refreshCoordinate(x: number, y: number): void;
+    protected fireScrollEvent(userAction: boolean): void;
+    protected onDragStart(): void;
+    reset(x?: number, y?: number): void;
+    stopAnimation(...ids: Array<number>): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollView, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnScrollView, "cn-scroll-view", never, { "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; "overscrollEnabled": { "alias": "overscrollEnabled"; "required": false; "isSignal": true; }; "scrollingSettings": { "alias": "scrollingSettings"; "required": false; "isSignal": true; }; "animationParams": { "alias": "animationParams"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * IScrollBarDragEvent
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/ng-scroll-bar/interfaces/scrollbar-drag-data.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+interface IScrollBarDragEvent {
+    position: number;
+    min: number;
+    max: number;
+    userAction: boolean;
+    animation: boolean;
+    isVertical: boolean;
+}
+
+declare enum ScrollbarStates {
+    NORMAL = 0,
+    PRESSED = 1,
+    HOVER = 2
+}
+
+/**
+ * CnScrollBarService
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-bar/cn-scroll-bar-public.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollBarPublicService {
+    private _internalService;
+    get $click(): rxjs.Observable<PointerEvent | MouseEvent>;
+    get $state(): rxjs.Observable<ScrollbarStates>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarPublicService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CnScrollBarPublicService>;
+}
+
+interface IScrollBarTemplateContext {
+    /**
+     * API provider
+     */
+    api: CnScrollBarPublicService;
+    /**
+     * Scrollbar thumb width.
+     */
+    width: number;
+    /**
+     * Scrollbar thumb height.
+     */
+    height: number;
+    /**
+     * Gradient fill position parameters.
+     */
+    fillPositions: GradientColorPositions;
+    /**
+     * Additional options for the scrollbar.
+     */
+    params: {
+        [propName: string]: any;
+    };
+}
+
+type ScrollbarState = ScrollbarStates;
+
+/**
+ * CnScrollBarService
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/ng-scroll-bar/ng-scroll-bar.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollBarService {
+    private _$click;
+    readonly $click: rxjs.Observable<PointerEvent | MouseEvent>;
+    private _$state;
+    readonly $state: rxjs.Observable<ScrollbarStates>;
+    set state(v: ScrollbarState);
+    get state(): ScrollbarState;
+    click(event: PointerEvent | MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CnScrollBarService>;
+}
+
+/**
+ * ScrollBar component.
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/cn-scroll-bar/cn-scroll-bar.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollBarComponent extends CnScrollView {
+    protected _defaultRenderer: Signal<TemplateRef<any> | undefined>;
+    protected _scrollBarService: CnScrollBarService;
+    private _apiService;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly onDrag: _angular_core.OutputEmitterRef<IScrollBarDragEvent>;
+    readonly onDragEnd: _angular_core.OutputEmitterRef<IScrollBarDragEvent>;
+    readonly thumbGradientPositions: _angular_core.InputSignal<GradientColorPositions>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly thickness: _angular_core.InputSignal<number>;
+    readonly scrollbarMinSize: _angular_core.InputSignal<number>;
+    readonly prepared: _angular_core.InputSignal<boolean>;
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    readonly overlapping: _angular_core.InputSignal<boolean>;
+    readonly show: _angular_core.InputSignal<boolean>;
+    readonly params: _angular_core.InputSignal<{
+        [propName: string]: any;
+    } | null>;
+    readonly renderer: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly thumbRenderer: _angular_core.WritableSignal<TemplateRef<any> | null>;
+    protected readonly hoverState: _angular_core.WritableSignal<boolean>;
+    protected readonly pressedState: _angular_core.WritableSignal<boolean>;
+    protected readonly templateContext: Signal<IScrollBarTemplateContext>;
+    protected readonly styles: Signal<{
+        [sName: string]: any;
+    }>;
+    protected readonly thumbWidth: Signal<number>;
+    protected readonly thumbHeight: Signal<number>;
+    protected readonly isVertical: Signal<boolean>;
+    private _$scrollingCancel;
+    protected readonly $scrollingCancel: rxjs.Observable<void>;
+    private _elementRef;
+    constructor();
+    private createDragEvent;
+    private thumbHit;
+    click(event: PointerEvent | MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnScrollBarComponent, "cn-scroll-bar", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "thumbGradientPositions": { "alias": "thumbGradientPositions"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; "isSignal": true; }; "prepared": { "alias": "prepared"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "overlapping": { "alias": "overlapping"; "required": false; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "renderer": { "alias": "renderer"; "required": false; "isSignal": true; }; }, { "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; }, never, never, false, never>;
+}
+
+/**
+ * The scroller for the CnVirtualScrollView item component
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/components/scroller/cn-scroller.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnScrollerComponent extends CnScrollView {
+    readonly scrollBarHorizontal: CnScrollBarComponent | undefined;
+    readonly scrollBarVertical: CnScrollBarComponent | undefined;
+    readonly filter: Signal<ElementRef<SVGFEGaussianBlurElement> | undefined>;
+    readonly onScrollbarVisible: _angular_core.OutputEmitterRef<boolean>;
+    readonly scrollbarEnabled: _angular_core.InputSignal<boolean>;
+    readonly scrollbarInteractive: _angular_core.InputSignal<boolean>;
+    readonly focusedElement: _angular_core.InputSignal<Id | null>;
+    readonly overlappingScrollbar: _angular_core.InputSignal<boolean>;
+    readonly content: _angular_core.InputSignal<HTMLElement | undefined>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly classes: _angular_core.InputSignal<{
+        [cName: string]: boolean;
+    }>;
+    readonly scrollbarMinSize: _angular_core.InputSignal<number>;
+    readonly scrollbarThickness: _angular_core.InputSignal<number>;
+    readonly scrollbarThumbRenderer: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly scrollbarThumbParams: _angular_core.InputSignal<{
+        [propName: string]: any;
+    } | null>;
+    readonly motionBlur: _angular_core.InputSignal<number | "disabled">;
+    readonly maxMotionBlur: _angular_core.InputSignal<number>;
+    readonly motionBlurEnabled: _angular_core.InputSignal<boolean>;
+    readonly actualClasses: Signal<{
+        [cName: string]: boolean;
+    }>;
+    readonly containerClasses: Signal<{
+        [cName: string]: boolean;
+    }>;
+    readonly thumbGradientPositionsHorizontal: _angular_core.WritableSignal<GradientColorPositions>;
+    readonly thumbGradientPositionsVertical: _angular_core.WritableSignal<GradientColorPositions>;
+    readonly thumbSizeVertical: _angular_core.WritableSignal<number>;
+    readonly thumbSizeHorizontal: _angular_core.WritableSignal<number>;
+    readonly scrollbarHorizontalEnabled: _angular_core.WritableSignal<boolean>;
+    readonly scrollbarVerticalEnabled: _angular_core.WritableSignal<boolean>;
+    readonly preparedSignal: _angular_core.WritableSignal<boolean>;
+    readonly listStyles: _angular_core.WritableSignal<{
+        perspectiveOrigin: string;
+    }>;
+    private _scrollBox;
+    get host(): HTMLDivElement | undefined;
+    private _$scrollbarScroll;
+    readonly $scrollbarScroll: rxjs.Observable<boolean>;
+    private _prepared;
+    set prepared(v: boolean);
+    protected setX(x: number, normalize?: boolean): void;
+    protected setY(y: number, normalize?: boolean): void;
+    set startLayoutOffsetX(v: number);
+    get startLayoutOffsetX(): number;
+    set startLayoutOffsetY(v: number);
+    get startLayoutOffsetY(): number;
+    readonly viewInitialized: _angular_core.WritableSignal<boolean>;
+    private _isScrollbarUserActionX;
+    get isScrollbarUserActionX(): boolean;
+    private _isScrollbarUserActionY;
+    get isScrollbarUserActionY(): boolean;
+    protected _$resizeViewport: Subject<ISize>;
+    readonly $resizeViewport: rxjs.Observable<ISize>;
+    protected _$resizeContent: Subject<ISize>;
+    readonly $resizeContent: rxjs.Observable<ISize>;
+    protected _filterId: string;
+    protected _filter: string;
+    constructor();
+    private recalculatePerspective;
+    protected onResizeViewport(): void;
+    protected onResizeContent(width?: number | null, height?: number | null): void;
+    private updateScrollBarHandler;
+    ngAfterViewInit(): void;
+    tick(): void;
+    private updateScrollBar;
+    protected normalizeScrollWidth(): boolean;
+    protected normalizeScrollHeight(): boolean;
+    refreshScrollbar(): void;
+    protected onDragStartHorizontal(): void;
+    protected onDragStartVertical(): void;
+    reset(): void;
+    refresh(fireUpdate?: boolean, updateScrollbar?: boolean): void;
+    startScrollTo(): void;
+    finishedScrollTo(): void;
+    scrollTo(params: IScrollToParams): Array<number> | null;
+    stopScrollbar(isVertical: boolean): void;
+    private dropVelocity;
+    protected stopMoving(): void;
+    protected onAnimationComplete(position: number): void;
+    onScrollBarDragHandler(event: IScrollBarDragEvent): void;
+    protected onScrollBarDragEndHandler(event: IScrollBarDragEvent): void;
+    private fireUpdateIfEdgesDetected;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnScrollerComponent, "cn-scroller", never, { "scrollbarEnabled": { "alias": "scrollbarEnabled"; "required": false; "isSignal": true; }; "scrollbarInteractive": { "alias": "scrollbarInteractive"; "required": false; "isSignal": true; }; "focusedElement": { "alias": "focusedElement"; "required": false; "isSignal": true; }; "overlappingScrollbar": { "alias": "overlappingScrollbar"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; "isSignal": true; }; "scrollbarThickness": { "alias": "scrollbarThickness"; "required": false; "isSignal": true; }; "scrollbarThumbRenderer": { "alias": "scrollbarThumbRenderer"; "required": false; "isSignal": true; }; "scrollbarThumbParams": { "alias": "scrollbarThumbParams"; "required": false; "isSignal": true; }; "motionBlur": { "alias": "motionBlur"; "required": false; "isSignal": true; }; "maxMotionBlur": { "alias": "maxMotionBlur"; "required": false; "isSignal": true; }; "motionBlurEnabled": { "alias": "motionBlurEnabled"; "required": false; "isSignal": true; }; }, { "onScrollbarVisible": "onScrollbarVisible"; }, never, ["*"], false, never>;
+}
+
+declare class CnScrollBarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollBarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnScrollBarModule, [typeof CnScrollBarComponent], [typeof i2.CommonModule], [typeof CnScrollBarComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnScrollBarModule>;
+}
+
+/**
+ * LocaleSensitiveDirective
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/directives/locale-sensitive/locale-sensitive.directive.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class LocaleSensitiveDirective {
+    langTextDir: _angular_core.InputSignal<TextDirection>;
+    listDir: _angular_core.InputSignal<ScrollerDirections>;
+    private _elementRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocaleSensitiveDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LocaleSensitiveDirective, "[localeSensitive]", never, { "langTextDir": { "alias": "langTextDir"; "required": false; "isSignal": true; }; "listDir": { "alias": "listDir"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class LocaleSensitiveModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocaleSensitiveModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<LocaleSensitiveModule, [typeof LocaleSensitiveDirective], [typeof i2.CommonModule], [typeof LocaleSensitiveDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<LocaleSensitiveModule>;
+}
+
+declare class CnScrollerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnScrollerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnScrollerModule, [typeof CnScrollerComponent], [typeof i2.CommonModule, typeof CnScrollBarModule, typeof LocaleSensitiveModule, typeof i5.CdkScrollableModule], [typeof CnScrollerComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnScrollerModule>;
+}
+
+/**
+ * CnVirtualScrollViewService
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/cn-virtual-scroll-view.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnVirtualScrollViewService implements IScrollViewService, OnDestroy {
+    private _id;
+    get id(): number;
+    private _nextComponentId;
+    private _$tick;
+    readonly $tick: rxjs.Observable<void>;
+    scrollLeftOffset: number;
+    scrollRightOffset: number;
+    scrollTopOffset: number;
+    scrollBottomOffset: number;
+    isInfinity: boolean;
+    isVertical: boolean;
+    snapScrollToLeft: boolean;
+    snapScrollToRight: boolean;
+    snapScrollToTop: boolean;
+    snapScrollToBottom: boolean;
+    animationParams: IAnimationParams;
+    listElement: HTMLDivElement | null;
+    direction: Direction;
+    private _$langTextDir;
+    readonly $langTextDir: rxjs.Observable<TextDirection>;
+    get langTextDir(): TextDirection;
+    set langTextDir(v: TextDirection);
+    private _$grabbing;
+    readonly $grabbing: rxjs.Observable<boolean>;
+    get grabbing(): boolean;
+    set grabbing(v: boolean);
+    private _$clickPressed;
+    readonly $clickPressed: rxjs.Observable<boolean>;
+    get clickPressed(): boolean;
+    set clickPressed(v: boolean);
+    private _$isGrabbing;
+    readonly $isGrabbing: rxjs.Observable<boolean>;
+    get isGrabbing(): boolean;
+    private _$scrollBarSize;
+    readonly $scrollBarSize: rxjs.Observable<number>;
+    get scrollBarSize(): number;
+    set scrollBarSize(v: number);
+    private _$intersectionElementBySnapToItemAlign;
+    readonly $intersectionElementBySnapToItemAlign: rxjs.Observable<Id | null>;
+    private _$clickDistance;
+    readonly $clickDistance: rxjs.Observable<number>;
+    get clickDistance(): number;
+    set clickDistance(v: number);
+    private _tickerId;
+    constructor();
+    private tick;
+    focusList(): void;
+    initialize(id: number): void;
+    generateComponentId(): number;
+    getComponentBoundsByIntersectionPosition(positionX: number, positionY: number, maxPositionX?: number | null, maxPositionY?: number | null): (IRect & {
+        id: Id | null;
+        isFirst: boolean;
+        isLast: boolean;
+    }) | null;
+    setIntersectionElementBySnapToItemAlign(id: Id | null): void;
+    update(immediately?: boolean): void;
+    /**
+     * Scrolls the scroll area to the first item in the collection.
+     */
+    scrollToLeft(options?: IScrollOptions): void;
+    /**
+     * Scrolls the list to the end of the content size.
+     */
+    scrollToRight(options?: IScrollOptions): void;
+    /**
+     * Scrolls the scroll area to the first item in the collection.
+     */
+    scrollToTop(options?: IScrollOptions): void;
+    /**
+     * Scrolls the list to the end of the content size.
+     */
+    scrollToBottom(options?: IScrollOptions): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualScrollViewService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CnVirtualScrollViewService>;
+}
+
+/**
+ * Virtual list component.
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/centrifugal/blob/main/src/lib/scroll-view/cn-virtual-scroll-view.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+declare class CnVirtualScrollViewComponent implements OnDestroy {
+    private static __nextId;
+    private _id;
+    /**
+     * Readonly. Returns the unique identifier of the component.
+     */
+    get id(): number;
+    private _service;
+    private _scrollerComponent;
+    private _scroller;
+    /**
+     * Fires when the list has been scrolled.
+     */
+    onScroll: _angular_core.OutputEmitterRef<IScrollEvent>;
+    /**
+     * Fires when the list has completed scrolling.
+     */
+    onScrollEnd: _angular_core.OutputEmitterRef<IScrollEvent>;
+    /**
+     * Fires when the viewport size is changed.
+     */
+    onViewportChange: _angular_core.OutputEmitterRef<ISize>;
+    /**
+     * Fires when the scroll reaches the left.
+     */
+    onScrollReachLeft: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Fires when the scroll reaches the right.
+     */
+    onScrollReachRight: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Fires when the scroll reaches the top.
+     */
+    onScrollReachTop: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Fires when the scroll reaches the bottom.
+     */
+    onScrollReachBottom: _angular_core.OutputEmitterRef<void>;
+    private _$show;
+    readonly $show: rxjs.Observable<boolean>;
+    private _$initialized;
+    readonly $initialized: rxjs.Observable<boolean>;
+    private _scrollbarThickness;
+    /**
+     * Scrollbar thickness.
+     */
+    scrollbarThickness: _angular_core.InputSignal<number>;
+    private _scrollbarMinSize;
+    /**
+     * Minimum scrollbar size.
+     */
+    scrollbarMinSize: _angular_core.InputSignal<number>;
+    private _scrollbarThumbRenderer;
+    /**
+     * Scrollbar customization template.
+     */
+    scrollbarThumbRenderer: _angular_core.InputSignal<TemplateRef<any> | null>;
+    private _scrollbarThumbParams;
+    /**
+     * Additional options for the scrollbar.
+     */
+    scrollbarThumbParams: _angular_core.InputSignal<{
+        [propName: string]: any;
+    } | null>;
+    private _clickDistance;
+    /**
+     * The maximum scroll distance at which a click event is triggered.
+     */
+    clickDistance: _angular_core.InputSignal<number>;
+    private _scrollLeftOffsetOptions;
+    /**
+     * Sets the scroll left offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    scrollLeftOffset: _angular_core.InputSignal<ArithmeticExpression>;
+    private _scrollTopOffsetOptions;
+    /**
+     * Sets the scroll top offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    scrollTopOffset: _angular_core.InputSignal<ArithmeticExpression>;
+    private _scrollRightOffsetOptions;
+    /**
+     * Sets the scroll right offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    scrollRightOffset: _angular_core.InputSignal<ArithmeticExpression>;
+    private _scrollBottomOffsetOptions;
+    /**
+     * Sets the scroll bottom offset value. Can be specified in absolute or percentage values.
+     * Supports arithmetic expressions of addition `50% + 25` or subtraction `50% - 25`. Default value is "0".
+     */
+    scrollBottomOffset: _angular_core.InputSignal<ArithmeticExpression>;
+    private _snapScrollToLeftOptions;
+    /**
+     * Determines whether the scrollbar is snapped to the left of the scroller. The default value is "true".
+     * That is, if snapScrollToLeft and snapScrollToRight are enabled, the scroller will initially snap
+     * to the left; if you move the scrollbar right, the scroller will snap to the right.
+     * If snapScrollToLeft is disabled and snapScrollToRight is enabled, the scroller will snap to the right;
+     * If you move the scrollbar left, the scroller will snap to the left.
+     * If both snapScrollToLeft and snapScrollToRight are disabled, the scroller will never snap to the left or right.
+     */
+    snapScrollToLeft: _angular_core.InputSignal<boolean>;
+    private _snapScrollToTopOptions;
+    /**
+     * Determines whether the scrollbar is snapped to the top of the scroller. The default value is "true".
+     * That is, if snapScrollToTop and snapScrollToBottom are enabled, the scroller will initially snap
+     * to the top; if you move the scrollbar down, the scroller will snap to the bottom.
+     * If snapScrollToTop is disabled and snapScrollToBottom is enabled, the scroller will snap to the bottom;
+     * If you move the scrollbar up, the scroller will snap to the top.
+     * If both snapScrollToTop and snapScrollToBottom are disabled, the scroller will never snap to the top or bottom.
+     */
+    snapScrollToTop: _angular_core.InputSignal<boolean>;
+    private _snapScrollToRightOptions;
+    /**
+     * Determines whether the scrollbar is snapped to the right of the scroller. The default value is "true".
+     * That is, if snapScrollToLeft and snapScrollToRight are enabled, the scroller will initially snap
+     * to the left; if you move the scrollbar right, the scroller will snap to the right.
+     * If snapScrollToLeft is disabled and snapScrollToRight is enabled, the scroller will snap to the right;
+     * If you move the scrollbar left, the scroller will snap to the left.
+     * If both snapScrollToLeft and snapScrollToRight are disabled, the scroller will never snap to the left or right.
+     */
+    snapScrollToRight: _angular_core.InputSignal<boolean>;
+    private _snapScrollToBottomOptions;
+    /**
+     * Determines whether the scrollbar is snapped to the bottom of the scroller. The default value is "true".
+     * That is, if snapScrollToTop and snapScrollToBottom are enabled, the scroller will initially snap
+     * to the top; if you move the scrollbar down, the scroller will snap to the bottom.
+     * If snapScrollToTop is disabled and snapScrollToBottom is enabled, the scroller will snap to the bottom;
+     * If you move the scrollbar up, the scroller will snap to the top.
+     * If both snapScrollToTop and snapScrollToBottom are disabled, the scroller will never snap to the top or bottom.
+     */
+    snapScrollToBottom: _angular_core.InputSignal<boolean>;
+    private _scrollableOptions;
+    /**
+     * Determines whether scrolling is enabled or disabled. The default value is "true".
+     */
+    scrollable: _angular_core.InputSignal<boolean>;
+    private _scrollbarEnabledOptions;
+    /**
+     * Determines whether the scrollbar is shown or not. The default value is "true".
+     */
+    scrollbarEnabled: _angular_core.InputSignal<boolean>;
+    private _scrollbarInteractiveOptions;
+    /**
+     * Determines whether scrolling using the scrollbar will be possible. The default value is "true".
+     */
+    scrollbarInteractive: _angular_core.InputSignal<boolean>;
+    private _overlappingScrollbarOptions;
+    /**
+     * Determines whether the scroll bar will overlap the list. The default value is "false".
+     */
+    overlappingScrollbar: _angular_core.InputSignal<boolean>;
+    private _scrollBehaviorOptions;
+    /**
+     * Defines the scrolling behavior for any element on the page. The default value is "smooth".
+     */
+    scrollBehavior: _angular_core.InputSignal<ScrollBehavior>;
+    private _scrollingSettingsOptions;
+    /**
+     * Scrolling settings.
+     * - frictionalForce - Frictional force. Default value is 0.035.
+     * - mass - Mass. Default value is 0.005.
+     * - maxDistance - Maximum scrolling distance. Default value is 100000.
+     * - maxDuration - Maximum animation duration. Default value is 4000.
+     * - speedScale - Speed scale. Default value is 10.
+     * - optimization - Enables scrolling performance optimization. Default value is `true`.
+     */
+    scrollingSettings: _angular_core.InputSignal<IScrollingSettings>;
+    private _motionBlurOptions;
+    /**
+     * Motion blur effect. The default value is `0.15`.
+     */
+    motionBlur: _angular_core.InputSignal<number>;
+    private _maxMotionBlurOptions;
+    /**
+     * Maximum motion blur effect. The default value is `0.5`.
+     */
+    maxMotionBlur: _angular_core.InputSignal<number>;
+    private _motionBlurEnabledOptions;
+    /**
+     * Determines whether to apply motion blur or not. The default value is `false`.
+     */
+    motionBlurEnabled: _angular_core.InputSignal<boolean>;
+    private _animationParamsOptions;
+    /**
+     * Animation parameters. The default value is "{ scrollToItem: 0 }".
+     */
+    animationParams: _angular_core.InputSignal<IAnimationParams>;
+    private _overscrollEnabledOptions;
+    /**
+     * Determines whether the overscroll (re-scroll) feature will work. The default value is "true".
+     */
+    overscrollEnabled: _angular_core.InputSignal<boolean>;
+    private _directionOptions;
+    /**
+     * Determines the direction in which elements are placed. Default value is "both".
+     */
+    direction: _angular_core.InputSignal<Direction>;
+    private _loading;
+    /**
+     * If `true`, the scrollBar goes into loading state. The default value is `false`.
+     */
+    loading: _angular_core.InputSignal<boolean>;
+    private _langTextDir;
+    /**
+     * A string indicating the direction of text for the locale.
+     * Can be either "ltr" (left-to-right) or "rtl" (right-to-left).
+     */
+    langTextDir: _angular_core.InputSignal<TextDirection>;
+    protected readonly focusedElement: _angular_core.WritableSignal<Id | null>;
+    protected readonly classes: _angular_core.WritableSignal<{
+        [cName: string]: boolean;
+    }>;
+    private _bounds;
+    protected get bounds(): _angular_core.WritableSignal<ISize | null>;
+    private _scrollerBounds;
+    private _$scrollSizeX;
+    private _$scrollSizeY;
+    private _isScrollLeft;
+    private _isScrollRight;
+    private _isScrollTop;
+    private _isScrollBottom;
+    protected _precalculatedScrollLeftOffset: _angular_core.WritableSignal<number>;
+    protected _precalculatedScrollTopOffset: _angular_core.WritableSignal<number>;
+    protected _precalculatedScrollRightOffset: _angular_core.WritableSignal<number>;
+    protected _precalculatedScrollBottomOffset: _angular_core.WritableSignal<number>;
+    private _elementRef;
+    private _$scroll;
+    readonly $scroll: rxjs.Observable<IScrollEvent>;
+    get $grabbing(): rxjs.Observable<boolean>;
+    private _$fireUpdate;
+    protected readonly $fireUpdate: rxjs.Observable<boolean>;
+    private _$fireUpdateNextFrame;
+    protected readonly $fireUpdateNextFrame: rxjs.Observable<boolean>;
+    private _$preventScrollSnapping;
+    protected readonly $preventScrollSnapping: rxjs.Observable<boolean>;
+    private _destroyRef;
+    private _isLoading;
+    private _animationIds;
+    private _$viewInit;
+    private readonly $viewInit;
+    private _injector;
+    constructor();
+    ngAfterViewInit(): void;
+    private onAfterResize;
+    private snappingHandler;
+    private emitScrollEvent;
+    /**
+     * The method scrolls the scroll view and returns the animation ids if the behavior is set to smooth or null
+     * if the behavior is set to auto, instant, or not set.
+     */
+    scrollTo(options: IScrollOptions): number[] | null;
+    /**
+     * Prevents the list from snapping to its start or end edge.
+     */
+    preventSnapping(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualScrollViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CnVirtualScrollViewComponent, "cn-virtual-scroll-view", never, { "scrollbarThickness": { "alias": "scrollbarThickness"; "required": false; "isSignal": true; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; "isSignal": true; }; "scrollbarThumbRenderer": { "alias": "scrollbarThumbRenderer"; "required": false; "isSignal": true; }; "scrollbarThumbParams": { "alias": "scrollbarThumbParams"; "required": false; "isSignal": true; }; "clickDistance": { "alias": "clickDistance"; "required": false; "isSignal": true; }; "scrollLeftOffset": { "alias": "scrollLeftOffset"; "required": false; "isSignal": true; }; "scrollTopOffset": { "alias": "scrollTopOffset"; "required": false; "isSignal": true; }; "scrollRightOffset": { "alias": "scrollRightOffset"; "required": false; "isSignal": true; }; "scrollBottomOffset": { "alias": "scrollBottomOffset"; "required": false; "isSignal": true; }; "snapScrollToLeft": { "alias": "snapScrollToLeft"; "required": false; "isSignal": true; }; "snapScrollToTop": { "alias": "snapScrollToTop"; "required": false; "isSignal": true; }; "snapScrollToRight": { "alias": "snapScrollToRight"; "required": false; "isSignal": true; }; "snapScrollToBottom": { "alias": "snapScrollToBottom"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "scrollbarEnabled": { "alias": "scrollbarEnabled"; "required": false; "isSignal": true; }; "scrollbarInteractive": { "alias": "scrollbarInteractive"; "required": false; "isSignal": true; }; "overlappingScrollbar": { "alias": "overlappingScrollbar"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; "scrollingSettings": { "alias": "scrollingSettings"; "required": false; "isSignal": true; }; "motionBlur": { "alias": "motionBlur"; "required": false; "isSignal": true; }; "maxMotionBlur": { "alias": "maxMotionBlur"; "required": false; "isSignal": true; }; "motionBlurEnabled": { "alias": "motionBlurEnabled"; "required": false; "isSignal": true; }; "animationParams": { "alias": "animationParams"; "required": false; "isSignal": true; }; "overscrollEnabled": { "alias": "overscrollEnabled"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "langTextDir": { "alias": "langTextDir"; "required": false; "isSignal": true; }; }, { "onScroll": "onScroll"; "onScrollEnd": "onScrollEnd"; "onViewportChange": "onViewportChange"; "onScrollReachLeft": "onScrollReachLeft"; "onScrollReachRight": "onScrollReachRight"; "onScrollReachTop": "onScrollReachTop"; "onScrollReachBottom": "onScrollReachBottom"; }, never, ["*"], false, never>;
+}
+
+declare class CnVirtualScrollViewModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CnVirtualScrollViewModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CnVirtualScrollViewModule, [typeof CnVirtualScrollViewComponent], [typeof i2.CommonModule, typeof CnScrollerModule, typeof LocaleSensitiveModule], [typeof CnVirtualScrollViewComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CnVirtualScrollViewModule>;
+}
+
+export { CnLocaleSensitiveDirective, CnLocaleSensitiveModule, CnScrollBarPublicService, CnScrollerComponent, CnScrollerModule, CnVirtualClickDirective, CnVirtualClickModule, CnVirtualListComponent, CnVirtualListModule, CnVirtualListPublicService, CnVirtualListService, CnVirtualScrollViewComponent, CnVirtualScrollViewModule, CnVirtualScrollViewService, TextDirections };
+export type { ArithmeticExpression, Color, FloatOrPersentageValue, GradientColorPosition, GradientColorPositions, IPoint, IRect, ISize, Id, TextDirection };