@cute-widgets/base 20.0.1

package/toolbar/index.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, QueryList } from '@angular/core';
+import { CuteLayoutControl } from '@cute-widgets/base/abstract';
+import * as i1 from '@angular/common';
+
+declare class CuteToolbarRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteToolbarRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteToolbarRow, "cute-toolbar-row", ["cuteToolbarRow"], {}, {}, never, never, true, never>;
+}
+declare class CuteToolbar extends CuteLayoutControl implements AfterViewInit {
+    private _platform;
+    private _document;
+    /** Reference to all toolbar row elements that have been projected. */
+    _toolbarRows: QueryList<CuteToolbarRow> | undefined;
+    constructor(...args: unknown[]);
+    generateId(): string;
+    ngAfterViewInit(): void;
+    /**
+     * Throws an exception when developers are attempting to combine the different toolbar row modes.
+     */
+    private _checkToolbarMixedModes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteToolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteToolbar, "cute-toolbar", ["cuteToolbar"], {}, {}, ["_toolbarRows"], ["*", "cute-toolbar-row"], true, never>;
+}
+/**
+ * Throws an exception when attempting to combine the different toolbar row modes.
+ */
+declare function throwToolbarMixedModesError(): void;
+
+declare class CuteToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteToolbarModule, never, [typeof i1.CommonModule, typeof CuteToolbar, typeof CuteToolbarRow], [typeof CuteToolbar, typeof CuteToolbarRow]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteToolbarModule>;
+}
+
+export { CuteToolbar, CuteToolbarModule, CuteToolbarRow, throwToolbarMixedModesError };

package/tooltip/index.d.ts

@@ -0,0 +1,299 @@
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, AfterViewInit, ElementRef } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { ScrollStrategy, Overlay, OverlayRef, ConnectedPosition } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+import * as i1 from '@angular/common';
+
+/** Possible positions for a tooltip. */
+type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+/**
+ * Options for how the tooltip trigger should handle touch gestures.
+ * See `CuteTooltip.touchGestures` for more information.
+ */
+type TooltipTouchGestures = 'auto' | 'on' | 'off';
+/** Possible visibility states of a tooltip. */
+type TooltipVisibility = 'initial' | 'visible' | 'hidden';
+/** Time in ms to throttle repositioning after scroll events. */
+declare const SCROLL_THROTTLE_MS = 20;
+/**
+ * Creates an error to be thrown if the user supplied an invalid tooltip position.
+ */
+declare function getCuteTooltipInvalidPositionError(position: string): Error;
+/** Injection token that determines the scroll handling while a tooltip is visible. */
+declare const CUTE_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function CUTE_TOOLTIP_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+declare const CUTE_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof CUTE_TOOLTIP_SCROLL_STRATEGY_FACTORY;
+};
+/** @docs-private */
+declare function CUTE_TOOLTIP_DEFAULT_OPTIONS_FACTORY(): CuteTooltipDefaultOptions;
+/** Injection token to be used to override the default options for `cuteTooltip`. */
+declare const CUTE_TOOLTIP_DEFAULT_OPTIONS: InjectionToken<CuteTooltipDefaultOptions>;
+/** Default `cuteTooltip` options that can be overridden. */
+interface CuteTooltipDefaultOptions {
+    /** Default delay when the tooltip is shown. */
+    showDelay: number;
+    /** Default delay when the tooltip is hidden. */
+    hideDelay: number;
+    /** Default delay when hiding the tooltip on a touch device. */
+    touchendHideDelay: number;
+    /** Time between the user putting the pointer on a tooltip trigger and the long press event being fired on a touch device. */
+    touchLongPressShowDelay?: number;
+    /** Default touch gesture handling for tooltips. */
+    touchGestures?: TooltipTouchGestures;
+    /** Default position for tooltips. */
+    position?: TooltipPosition;
+    /**
+     * Default value for whether tooltips should be positioned near the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    positionAtOrigin?: boolean;
+    /** Disables the ability for the user to interact with the tooltip element. */
+    disableTooltipInteractivity?: boolean;
+    /**
+     * Default classes to be applied to the tooltip. These default classes will not be applied if
+     * `tooltipClass` is defined directly on the tooltip element, as it will override the default.
+     */
+    tooltipClass?: string | string[];
+}
+/**
+ * Directive that attaches a tooltip to the host element. Animates the showing and
+ * hiding of a tooltip-provided position (defaults to below the element).
+ *
+ * https://material.io/design/components/tooltips.html
+ */
+declare class CuteTooltip implements OnDestroy, AfterViewInit {
+    private _overlay;
+    private _elementRef;
+    private _scrollDispatcher;
+    private _viewContainerRef;
+    private _ngZone;
+    private _platform;
+    private _ariaDescriber;
+    private _focusMonitor;
+    protected _dir: Directionality;
+    private _injector;
+    private _defaultOptions;
+    protected _overlayRef: OverlayRef | null;
+    protected _tooltipInstance: TooltipComponent | null;
+    private _portal;
+    private _viewInitialized;
+    private _pointerExitEventsInitialized;
+    private readonly _scrollStrategy;
+    private readonly _tooltipComponent;
+    private _viewportMargin;
+    private _currentPosition;
+    private readonly _cssClassPrefix;
+    private _ariaDescriptionPending;
+    private _dirSubscribed;
+    /** Allows the user to define the position of the tooltip relative to the parent element */
+    get position(): TooltipPosition;
+    set position(value: TooltipPosition);
+    private _position;
+    /**
+     * Whether tooltip should be relative to the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    get positionAtOrigin(): boolean;
+    set positionAtOrigin(value: BooleanInput);
+    private _positionAtOrigin;
+    /** Disables the display of the tooltip. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    /** The default delay in ms before showing the tooltip after show is called */
+    get showDelay(): number;
+    set showDelay(value: NumberInput);
+    private _showDelay;
+    /** The default delay in ms before hiding the tooltip after hide is called */
+    get hideDelay(): number;
+    set hideDelay(value: NumberInput);
+    private _hideDelay;
+    /**
+     * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive
+     * uses a long press gesture to show and hide; however, it can conflict with the native browser
+     * gestures. To work around the conflict, Angular Material disables native gestures on the
+     * trigger, but that might not be desirable on particular elements (e.g., inputs and draggable
+     * elements). The different values for this option configure the touch event handling as follows:
+     * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native
+     *   browser gestures on particular elements. In particular, it allows text selection on inputs
+     *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.
+     * - `on` - Enables touch gestures for all elements and disables native
+     *   browser gestures with no exceptions.
+     * - `off` - Disables touch gestures. Note that this will prevent the tooltip from
+     *   showing on touch devices.
+     */
+    touchGestures: TooltipTouchGestures;
+    /** The message to be displayed in the tooltip */
+    get message(): string;
+    set message(value: string);
+    private _message;
+    /** Classes to be passed to the tooltip. Supports the same syntax as `ngClass`. */
+    get tooltipClass(): string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    set tooltipClass(value: string | string[] | Set<string> | {
+        [key: string]: any;
+    });
+    private _tooltipClass;
+    /** Manually bound passive event listeners. */
+    private readonly _passiveListeners;
+    /** Reference to the current document. */
+    private _document;
+    /** The Timer started at the last `touchstart` event. */
+    private _touchstartTimeout;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    /**
+     * Dispose the tooltip when destroyed.
+     */
+    ngOnDestroy(): void;
+    /** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */
+    show(delay?: number, origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */
+    hide(delay?: number): void;
+    /** Shows/hides the tooltip */
+    toggle(origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Returns true if the tooltip is currently visible to the user */
+    protected _isTooltipVisible(): boolean;
+    /** Create the overlay config and position strategy */
+    private _createOverlay;
+    /** Detaches the currently attached tooltip. */
+    private _detach;
+    /** Updates the position of the current tooltip. */
+    private _updatePosition;
+    /** Adds the configured offset to a position. Used as a hook for child classes. */
+    protected _addOffset(position: ConnectedPosition): ConnectedPosition;
+    /**
+     * Returns the origin position and a fallback position based on the user's position preference.
+     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).
+     */
+    private _getOrigin;
+    /** Returns the overlay position and a fallback position based on the user's preference */
+    private _getOverlayPosition;
+    /** Updates the tooltip message and repositions the overlay according to the new message length */
+    private _updateTooltipMessage;
+    /** Updates the tooltip class */
+    private _setTooltipClass;
+    /** Inverts an overlay position. */
+    private _invertPosition;
+    /** Updates the class on the overlay panel based on the current position of the tooltip. */
+    private _updateCurrentPositionClass;
+    /** Binds the pointer events to the tooltip trigger. */
+    private _setupPointerEnterEventsIfNeeded;
+    private _setupPointerExitEventsIfNeeded;
+    private _addListeners;
+    private _platformSupportsMouseEvents;
+    /** Listener for the `wheel` event on the element. */
+    private _wheelListener;
+    /** Disables the native browser gestures, based on how the tooltip has been configured. */
+    private _disableNativeGesturesIfNecessary;
+    /** Updates the tooltip's ARIA description based on it current state. */
+    private _syncAriaDescription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTooltip, "[cuteTooltip]", ["cuteTooltip"], { "position": { "alias": "cuteTooltipPosition"; "required": false; }; "positionAtOrigin": { "alias": "cuteTooltipPositionAtOrigin"; "required": false; }; "disabled": { "alias": "cuteTooltipDisabled"; "required": false; }; "showDelay": { "alias": "cuteTooltipShowDelay"; "required": false; }; "hideDelay": { "alias": "cuteTooltipHideDelay"; "required": false; }; "touchGestures": { "alias": "cuteTooltipTouchGestures"; "required": false; }; "message": { "alias": "cuteTooltip"; "required": false; }; "tooltipClass": { "alias": "cuteTooltipClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Internal component that wraps the tooltip's content.
+ */
+declare class TooltipComponent implements OnDestroy {
+    private _changeDetectorRef;
+    protected _elementRef: ElementRef<HTMLElement>;
+    _isMultiline: boolean;
+    /** Message to display in the tooltip */
+    message: string | undefined;
+    /** Classes to be added to the tooltip. Supports the same syntax as `ngClass`. */
+    tooltipClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    } | undefined;
+    /** The timeout ID of any current timer set to show the tooltip */
+    private _showTimeoutId;
+    /** The timeout ID of any current timer set to hide the tooltip */
+    private _hideTimeoutId;
+    /** Element that caused the tooltip to open. */
+    _triggerElement: HTMLElement | undefined;
+    /** Number of milliseconds to delay the closing sequence. */
+    _mouseLeaveHideDelay: number;
+    /** Whether animations are currently disabled. */
+    private _animationsDisabled;
+    /** Reference to the internal tooltip element. */
+    readonly _tooltip: ElementRef<HTMLElement> | undefined;
+    /** Whether interactions on the page should close the tooltip */
+    private _closeOnInteraction;
+    /** Whether the tooltip is currently visible. */
+    private _isVisible;
+    /** Subject for notifying that the tooltip has been hidden from the view */
+    private readonly _onHide;
+    /** Name of the show animation and the class that toggles it. */
+    private readonly _showAnimation;
+    /** Name of the hide animation and the class that toggles it. */
+    private readonly _hideAnimation;
+    constructor(...args: unknown[]);
+    /**
+     * Shows the tooltip with an animation originating from the provided origin
+     * @param delay Amount of milliseconds to the delay showing the tooltip.
+     */
+    show(delay: number): void;
+    /**
+     * Begins the animation to hide the tooltip after the provided delay in ms.
+     * @param delay Amount of milliseconds to delay showing the tooltip.
+     */
+    hide(delay: number): void;
+    /** Returns an observable that notifies when the tooltip has been hidden from view. */
+    afterHidden(): Observable<void>;
+    /** Whether the tooltip is being displayed. */
+    isVisible(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Interactions on the HTML body should close the tooltip immediately as defined in the
+     * material design spec.
+     * https://material.io/design/components/tooltips.html#behavior
+     */
+    _handleBodyInteraction(): void;
+    /**
+     * Marks that the tooltip needs to be checked in the next change detection run.
+     * Mainly used for rendering the initial text before positioning a tooltip, which
+     * can be problematic in components with OnPush change detection.
+     */
+    _markForCheck(): void;
+    _handleMouseLeave({ relatedTarget }: MouseEvent): void;
+    /**
+     * Callback for when the timeout in this.show() gets completed.
+     */
+    protected _onShow(): void;
+    /** Whether the tooltip text has overflown to the next line */
+    private _isTooltipMultiline;
+    /** Event listener dispatched when an animation on the tooltip finishes. */
+    _handleAnimationEnd({ animationName }: AnimationEvent): void;
+    /** Cancels any pending animation sequences. */
+    _cancelPendingAnimations(): void;
+    /** Handles the cleanup after an animation has finished. */
+    private _finalizeAnimation;
+    /** Toggles the visibility of the tooltip element. */
+    private _toggleVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "cute-tooltip-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class CuteTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteTooltipModule, never, [typeof i1.CommonModule, typeof CuteTooltip], [typeof CuteTooltip]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteTooltipModule>;
+}
+
+export { CUTE_TOOLTIP_DEFAULT_OPTIONS, CUTE_TOOLTIP_DEFAULT_OPTIONS_FACTORY, CUTE_TOOLTIP_SCROLL_STRATEGY, CUTE_TOOLTIP_SCROLL_STRATEGY_FACTORY, CUTE_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER, CuteTooltip, CuteTooltipModule, SCROLL_THROTTLE_MS, TooltipComponent, getCuteTooltipInvalidPositionError };
+export type { CuteTooltipDefaultOptions, TooltipPosition, TooltipTouchGestures, TooltipVisibility };

package/tree/index.d.ts

@@ -0,0 +1,314 @@
+import * as i1 from '@angular/cdk/tree';
+import { CdkTreeNode, CdkTreeNodeDef, CdkNestedTreeNode, CdkTreeNodePadding, CdkTreeNodeOutlet, CdkTree, CdkTreeNodeToggle, TreeControl, FlatTreeControl } from '@angular/cdk/tree';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, AfterContentInit, ViewContainerRef, EventEmitter } from '@angular/core';
+import { DataSource, CollectionViewer } from '@angular/cdk/collections';
+import { Observable } from 'rxjs';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Wrapper for the CdkTree node with CuteWidget's design styles.
+ */
+declare class CuteTreeNode<T, K = T> extends CdkTreeNode<T, K> implements OnInit, OnDestroy {
+    /**
+     * The tabindex of the tree node.
+     *
+     * @deprecated By default CuteTreeNode manages focus using TreeKeyManager instead of tabIndex.
+     *   Recommend to avoid setting tabIndex directly to prevent TreeKeyManager from getting into
+     *   an unexpected state. Tabindex to be removed in a future version.
+     * @breaking-change 21.0.0 Remove this attribute.
+     */
+    get tabIndexInputBinding(): number;
+    set tabIndexInputBinding(value: number);
+    private _tabIndexInputBinding;
+    /**
+     * The default tabindex of the tree node.
+     *
+     * @deprecated By default CuteTreeNode manages focus using TreeKeyManager instead of tabIndex.
+     *   Recommend to avoid setting tabIndex directly to prevent TreeKeyManager form getting into
+     *   an unexpected state. Tabindex to be removed in a future version.
+     * @breaking-change 21.0.0 Remove this attribute.
+     */
+    defaultTabIndex: number;
+    protected _getTabindexAttribute(): number | null;
+    /**
+     * Whether the component is disabled.
+     *
+     * @deprecated This is an alias for `isDisabled`.
+     * @breaking-change 21.0.0 Remove this input
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTreeNode<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTreeNode<any, any>, "cute-tree-node", ["cuteTreeNode"], { "cdkTreeNodeTypeaheadLabel": { "alias": "cuteTreeNodeTypeaheadLabel"; "required": false; }; "tabIndexInputBinding": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "activation": "activation"; "expandedChange": "expandedChange"; }, never, never, true, never>;
+    static ngAcceptInputType_tabIndexInputBinding: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+/**
+ * Wrapper for the CdkTree node definition with CuteWidgets' design styles.
+ * Captures the node's template and a `when` predicate that describes when this node should be used.
+ */
+declare class CuteTreeNodeDef<T> extends CdkTreeNodeDef<T> {
+    data: T | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTreeNodeDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTreeNodeDef<any>, "[cuteTreeNodeDef]", never, { "when": { "alias": "cuteTreeNodeDefWhen"; "required": false; }; "data": { "alias": "cuteTreeNode"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Wrapper for the CdkTree nested node with CuteWidgets' design styles.
+ */
+declare class CuteNestedTreeNode<T, K = T> extends CdkNestedTreeNode<T, K> implements AfterContentInit, OnDestroy, OnInit {
+    node: T | undefined;
+    /**
+     * Whether the node is disabled.
+     *
+     * @deprecated This is an alias for `isDisabled`.
+     * @breaking-change 21.0.0 Remove this input
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Tabindex of the node. */
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    private _tabIndex;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNestedTreeNode<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteNestedTreeNode<any, any>, "cute-nested-tree-node", ["cuteNestedTreeNode"], { "node": { "alias": "cuteNestedTreeNode"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "activation": "activation"; "expandedChange": "expandedChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_tabIndex: unknown;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Wrapper for the CdkTree padding with **CuteWidgets** design styles.
+ */
+declare class CuteTreeNodePadding<T, K = T> extends CdkTreeNodePadding<T, K> {
+    /** The level of depth of the tree node. The padding will be `level * indent` pixels. */
+    get level(): number;
+    set level(value: number);
+    /** The indent for each level. Default number 40px from material design menu submenu spec. */
+    get indent(): number | string;
+    set indent(indent: number | string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTreeNodePadding<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTreeNodePadding<any, any>, "[cuteTreeNodePadding]", never, { "level": { "alias": "cuteTreeNodePadding"; "required": false; }; "indent": { "alias": "cuteTreeNodePaddingIndent"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_level: unknown;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Outlet for nested CdkNode. Put `[cuteTreeNodeOutlet]` on a tag to place children dataNodes
+ * inside the outlet.
+ */
+declare class CuteTreeNodeOutlet implements CdkTreeNodeOutlet {
+    readonly viewContainer: ViewContainerRef;
+    readonly _node: {} | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTreeNodeOutlet, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTreeNodeOutlet, "[cuteTreeNodeOutlet]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Wrapper for the CdkTable with **CuteWidgets** design styles.
+ */
+declare class CuteTree<T, K = T> extends CdkTree<T, K> {
+    private _renderChanges;
+    /** Event emitted on each change in the rendered data. */
+    renderNodesChange: EventEmitter<T[]>;
+    _nodeOutlet: CuteTreeNodeOutlet;
+    constructor();
+    renderNodeChanges(data: T[]): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTree<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteTree<any, any>, "cute-tree", ["cuteTree"], {}, { "renderNodesChange": "renderNodesChange"; }, never, never, true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Wrapper for the CdkTree's toggle with **CuteWidgets** design styles.
+ */
+declare class CuteTreeNodeToggle<T, K = T> extends CdkTreeNodeToggle<T, K> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTreeNodeToggle<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTreeNodeToggle<any, any>, "[cuteTreeNodeToggle]", never, { "recursive": { "alias": "cuteTreeNodeToggleRecursive"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Tree flattener to convert a normal type of node to node with children & level information.
+ * Transform nested nodes of type `T` to flattened nodes of type `F`.
+ *
+ * For example, the input data of type `T` is nested, and contains its children data:
+ *   SomeNode: {
+ *     key: 'Fruits',
+ *     children: [
+ *       NodeOne: {
+ *         key: 'Apple',
+ *       },
+ *       NodeTwo: {
+ *        key: 'Pear',
+ *      }
+ *    ]
+ *  }
+ *  After flattener flatten the tree, the structure will become
+ *  SomeNode: {
+ *    key: 'Fruits',
+ *    expandable: true,
+ *    level: 1
+ *  },
+ *  NodeOne: {
+ *    key: 'Apple',
+ *    expandable: false,
+ *    level: 2
+ *  },
+ *  NodeTwo: {
+ *   key: 'Pear',
+ *   expandable: false,
+ *   level: 2
+ * }
+ * and the output flattened type is `F` with additional information.
+ */
+declare class CuteTreeFlattener<T, F, K = F> {
+    transformFunction: (node: T, level: number) => F;
+    getLevel: (node: F) => number;
+    isExpandable: (node: F) => boolean;
+    getChildren: (node: T) => Observable<T[]> | T[] | undefined | null;
+    constructor(transformFunction: (node: T, level: number) => F, getLevel: (node: F) => number, isExpandable: (node: F) => boolean, getChildren: (node: T) => Observable<T[]> | T[] | undefined | null);
+    private _flattenNode;
+    private _flattenChildren;
+    /**
+     * Flatten a list of node type T to a flattened version of node F.
+     * Please note that type T may be nested, and the length of `structuredData` may be different
+     * from that of a returned list `F[]`.
+     */
+    flattenNodes(structuredData: T[]): F[];
+    /**
+     * Expand flattened node with current expansion status.
+     * The returned list may have different length.
+     */
+    expandFlattenedNodes(nodes: F[], treeControl: TreeControl<F, K>): F[];
+}
+/**
+ * Data source for a flat tree.
+ * The data source needs to handle expansion/collapsion of the tree node and change the data feed
+ * to `CuteTree`.
+ * The nested tree nodes of type `T` are flattened through `CuteTreeFlattener`, and converted
+ * to type `F` for `CuteTree` to consume.
+ */
+declare class CuteTreeFlatDataSource<T, F, K = F> extends DataSource<F> {
+    private _treeControl;
+    private _treeFlattener;
+    private readonly _flattenedData;
+    private readonly _expandedData;
+    get data(): T[];
+    set data(value: T[]);
+    private readonly _data;
+    constructor(_treeControl: FlatTreeControl<F, K>, _treeFlattener: CuteTreeFlattener<T, F, K>, initialData?: T[]);
+    connect(collectionViewer: CollectionViewer): Observable<F[]>;
+    disconnect(): void;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Data source for a nested tree.
+ *
+ * The data source for a nested tree doesn't have to consider node flattener, or the way to expand
+ * or collapse. The expansion/collapsion will be handled by TreeControl and each non-leaf node.
+ */
+declare class CuteTreeNestedDataSource<T> extends DataSource<T> {
+    /**
+     * Data for the nested tree
+     */
+    get data(): T[];
+    set data(value: T[]);
+    private readonly _data;
+    connect(collectionViewer: CollectionViewer): Observable<T[]>;
+    disconnect(): void;
+}
+
+declare class CuteTreeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTreeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteTreeModule, never, [typeof i1.CdkTreeModule, typeof CuteNestedTreeNode, typeof CuteTreeNodeDef, typeof CuteTreeNodePadding, typeof CuteTreeNodeToggle, typeof CuteTree, typeof CuteTreeNode, typeof CuteTreeNodeOutlet], [typeof CuteNestedTreeNode, typeof CuteTreeNodeDef, typeof CuteTreeNodePadding, typeof CuteTreeNodeToggle, typeof CuteTree, typeof CuteTreeNode, typeof CuteTreeNodeOutlet]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteTreeModule>;
+}
+
+export { CuteNestedTreeNode, CuteTree, CuteTreeFlatDataSource, CuteTreeFlattener, CuteTreeModule, CuteTreeNestedDataSource, CuteTreeNode, CuteTreeNodeDef, CuteTreeNodeOutlet, CuteTreeNodePadding, CuteTreeNodeToggle };