@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-slider.d.ts

@@ -0,0 +1,85 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class SliderThumb implements ControlValueAccessor, OnInit, OnDestroy {
+    private _elementRef;
+    readonly _slider: Slider;
+    readonly valueChange: _angular_core.OutputEmitterRef<number>;
+    valueInput: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    private _value;
+    getId(): string;
+    get value(): number;
+    set value(v: number);
+    private _clampValue;
+    constructor();
+    private _onChangeFn;
+    private _onTouchedFn;
+    ngOnInit(): void;
+    get min(): number;
+    get max(): number;
+    get step(): number;
+    ngOnDestroy(): void;
+    _updateValueFromUser(value: number): void;
+    _onInput(event: Event): void;
+    _onChange(event: Event): void;
+    _onBlur(): void;
+    _onFocus(): void;
+    focus(): void;
+    private _isUserInteraction;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private _updateHostValue;
+    get percentage(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SliderThumb, "input[ngsSliderThumb]", ["ngsSliderThumb"], { "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class Slider {
+    private elementRef;
+    readonly _cdr: ChangeDetectorRef;
+    private readonly _dir;
+    private readonly _destroyRef;
+    private readonly _document;
+    private readonly _platformId;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    discrete: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    showTickMarks: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    min: _angular_core.InputSignalWithTransform<number, unknown>;
+    max: _angular_core.InputSignalWithTransform<number, unknown>;
+    step: _angular_core.InputSignalWithTransform<number, unknown>;
+    displayWith: _angular_core.InputSignal<(value: number) => string>;
+    _allThumbs: _angular_core.Signal<readonly SliderThumb[]>;
+    _trackLeft: _angular_core.Signal<number>;
+    _trackRight: _angular_core.Signal<number>;
+    _activeThumb: _angular_core.WritableSignal<SliderThumb | null>;
+    _isDragging: _angular_core.WritableSignal<boolean>;
+    _tickMarks: _angular_core.Signal<any[]>;
+    _isRtl: boolean;
+    constructor();
+    private _initializeEvents;
+    _onValueChange(thumb: SliderThumb): void;
+    private _findClosestThumb;
+    _onPointerDown(event: MouseEvent | TouchEvent): void;
+    _onPointerMove(event: MouseEvent | TouchEvent): void;
+    private _calculatePercentage;
+    private _calculateValueFromPercentage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Slider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Slider, "ngs-slider", ["ngsSlider"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "discrete": { "alias": "discrete"; "required": false; "isSignal": true; }; "showTickMarks": { "alias": "showTickMarks"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "displayWith": { "alias": "displayWith"; "required": false; "isSignal": true; }; }, {}, ["_allThumbs"], ["*"], true, never>;
+}
+
+declare class SliderStartThumb extends SliderThumb {
+    getId(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderStartThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SliderStartThumb, "input[ngsSliderStartThumb]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SliderEndThumb extends SliderThumb {
+    getId(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderEndThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SliderEndThumb, "input[ngsSliderEndThumb]", never, {}, {}, never, never, true, never>;
+}
+
+export { Slider, SliderEndThumb, SliderStartThumb, SliderThumb };

package/types/ngstarter-ui-components-snack-bar.d.ts

@@ -0,0 +1,142 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ViewContainerRef, OnDestroy, EventEmitter, Type, TemplateRef } from '@angular/core';
+import { AriaLivePoliteness } from '@angular/cdk/a11y';
+import { Direction } from '@angular/cdk/bidi';
+import { Observable } from 'rxjs';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+
+/** Injection token that can be used to access the data that was passed in to a snack bar. */
+declare const SNACK_BAR_DATA: InjectionToken<any>;
+/** Injection token that can be used to specify default snack bar. */
+declare const SNACK_BAR_CONFIG: InjectionToken<SnackBarConfig<any>>;
+/** Function to provide the snack bar configuration. */
+declare function provideSnackBarConfig(config: SnackBarConfig): {
+    provide: InjectionToken<SnackBarConfig<any>>;
+    useValue: SnackBarConfig<any>;
+};
+type SnackBarHorizontalPosition = 'start' | 'center' | 'end' | 'left' | 'right';
+type SnackBarVerticalPosition = 'top' | 'bottom';
+declare class SnackBarConfig<D = any> {
+    /** The politeness level for the MatAriaLiveAnnouncer announcement. */
+    politeness?: AriaLivePoliteness;
+    /** Message to be announced by the LiveAnnouncer. */
+    announcementMessage?: string;
+    /** The view container that should be used for the snack bar's origin. */
+    viewContainerRef?: ViewContainerRef;
+    /** The duration in milliseconds to wait before automatically closing the snack bar. */
+    duration?: number;
+    /** Extra CSS classes to be added to the snack bar container. */
+    panelClass?: string | string[];
+    /** Text layout direction for the snack bar. */
+    direction?: Direction;
+    /** The horizontal position to place the snack bar. */
+    horizontalPosition?: SnackBarHorizontalPosition;
+    /** The vertical position to place the snack bar. */
+    verticalPosition?: SnackBarVerticalPosition;
+    /** Data being injected into the child component. */
+    data?: D | null;
+}
+
+declare class SnackBarRef<T> {
+    containerInstance: any;
+    private _overlayRef;
+    /** The instance of the component making up the content of the snack bar. */
+    instance: T;
+    /** Subject for notifying the user that the snack bar has been dismissed. */
+    private readonly _afterDismissed;
+    /** Subject for notifying the user that the snack bar has opened and appeared. */
+    private readonly _afterOpened;
+    constructor(containerInstance: any, _overlayRef: OverlayRef);
+    /** Dismisses the snack bar. */
+    dismiss(): void;
+    /** Gets an observable that is notified when the snack bar is finished closing. */
+    afterDismissed(): Observable<void>;
+    /** Gets an observable that is notified when the snack bar has opened and appeared. */
+    afterOpened(): Observable<void>;
+}
+
+declare class SnackBarContainer extends BasePortalOutlet implements OnDestroy {
+    snackBarConfig: SnackBarConfig;
+    readonly _portalOutlet: i0.Signal<CdkPortalOutlet>;
+    private _cdr;
+    private _platformId;
+    /** State of the snack bar animation. */
+    readonly animationState: i0.WritableSignal<"void" | "visible" | "hidden-top" | "hidden-bottom">;
+    readonly leaving: i0.WritableSignal<boolean>;
+    /** Event emitted when the snack bar exit animation is finished. */
+    readonly _onExit: EventEmitter<void>;
+    /** Event emitted when the snack bar enter animation is finished. */
+    readonly _onEnter: EventEmitter<void>;
+    constructor(snackBarConfig: SnackBarConfig);
+    /** Attach a component portal as content to this snack bar container. */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): any;
+    /** Attach a template portal as content to this snack bar container. */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): any;
+    /** Begin animation of snack bar entrance into view. */
+    enter(): void;
+    /** Begin animation of snack bar exit from view. */
+    exit(): void;
+    /** Handle end of transition. */
+    onTransitionEnd(event: TransitionEvent): void;
+    /** Asserts that no content is already attached to the container. */
+    private _assertNotAttached;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SnackBarContainer, "ngs-snack-bar-container", ["ngsSnackBarContainer"], {}, {}, never, never, true, never>;
+}
+
+declare class SimpleSnackBar {
+    readonly snackBarRef: SnackBarRef<any>;
+    readonly data: any;
+    /** Performs the action on the snack bar. */
+    action(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleSnackBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleSnackBar, "ngs-simple-snack-bar", ["ngsSimpleSnackBar"], {}, {}, never, never, true, never>;
+}
+
+declare class SnackBar {
+    private _overlay;
+    private _injector;
+    private _parentSnackBar;
+    private _defaultConfig;
+    /** Reference to the currently-opened snack bar. */
+    private _openedSnackBarRef;
+    /**
+     * Opens a snack bar with a message and an optional action.
+     */
+    open(message: string, action?: string, config?: SnackBarConfig): SnackBarRef<SimpleSnackBar>;
+    /**
+     * Opens a snack bar with a custom component.
+     */
+    openFromComponent<T>(component: Type<T>, config?: SnackBarConfig): SnackBarRef<T>;
+    /**
+     * Opens a snack bar with a custom template.
+     */
+    openFromTemplate(template: TemplateRef<any>, config?: SnackBarConfig): SnackBarRef<any>;
+    /**
+     * Dismisses the currently-visible snack bar.
+     */
+    dismiss(): void;
+    /**
+     * Attaches the snack bar container and the appropriate content.
+     */
+    private _attach;
+    /**
+     * Creates a new overlay and configures it for the snack bar.
+     */
+    private _createOverlay;
+    /**
+     * Attaches the snack bar container to the overlay.
+     */
+    private _attachContainer;
+    /**
+     * Creates an injector to be used inside of a snack bar component.
+     */
+    private _createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBar, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SnackBar>;
+}
+
+export { SNACK_BAR_CONFIG, SNACK_BAR_DATA, SimpleSnackBar, SnackBar, SnackBarConfig, SnackBarContainer, SnackBarRef, provideSnackBarConfig };
+export type { SnackBarHorizontalPosition, SnackBarVerticalPosition };

package/types/ngstarter-ui-components-sort.d.ts

@@ -0,0 +1,66 @@
+import * as _angular_core from '@angular/core';
+import { OutputEmitterRef, InjectionToken, OnInit, OnChanges, OnDestroy } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import * as _ngstarter_ui_components_sort from '@ngstarter-ui/components/sort';
+
+type SortDirection = 'asc' | 'desc' | '';
+
+interface Sort {
+    readonly active: string;
+    readonly direction: SortDirection;
+}
+interface EmrSort {
+    readonly active: string | (() => string);
+    readonly direction: SortDirection | (() => SortDirection);
+    readonly sortChange: Observable<Sort> | OutputEmitterRef<Sort>;
+    readonly initialized?: Observable<void>;
+}
+declare const SORT: InjectionToken<EmrSort>;
+
+declare class SortDirective implements OnInit, OnChanges, OnDestroy, EmrSort {
+    active: _angular_core.ModelSignal<string>;
+    start: _angular_core.InputSignal<SortDirection>;
+    direction: _angular_core.ModelSignal<SortDirection>;
+    disableClear: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly sortChange: _angular_core.OutputEmitterRef<Sort>;
+    readonly _stateChanges: Subject<void>;
+    private readonly _initialized;
+    readonly initialized: rxjs.Observable<void>;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    sort(id: string): void;
+    getNextSortDirection(id: string): SortDirection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SortDirective, "[ngsSort]", ["ngsSort"], { "active": { "alias": "ngsSortActive"; "required": false; "isSignal": true; }; "start": { "alias": "ngsSortStart"; "required": false; "isSignal": true; }; "direction": { "alias": "ngsSortDirection"; "required": false; "isSignal": true; }; "disableClear": { "alias": "ngsSortDisableClear"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngsSortDisabled"; "required": false; "isSignal": true; }; }, { "active": "ngsSortActiveChange"; "direction": "ngsSortDirectionChange"; "sortChange": "ngsSortChange"; }, never, never, true, never>;
+}
+
+declare class SortHeader implements OnInit, OnDestroy {
+    private _rerenderSubscription;
+    private _cdr;
+    id: _angular_core.InputSignal<string>;
+    sortActionDescription: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    _sort: _ngstarter_ui_components_sort.EmrSort | null;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    _handleClick(): void;
+    _getNextSortDirection(): string;
+    _isSorted(): boolean;
+    _isDisabled(): boolean;
+    _isSortDisabled(): boolean;
+    _getArrowState(): _ngstarter_ui_components_sort.SortDirection | "void";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SortHeader, "[ngs-sort-header]", ["ngsSortHeader"], { "id": { "alias": "ngs-sort-header"; "required": false; "isSignal": true; }; "sortActionDescription": { "alias": "sortActionDescription"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SortModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SortModule, never, [typeof SortDirective, typeof SortHeader], [typeof SortDirective, typeof SortHeader]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SortModule>;
+}
+
+export { SORT, SortDirective, SortHeader, SortModule };
+export type { EmrSort, Sort, SortDirection };

package/types/ngstarter-ui-components-spinner.d.ts

@@ -0,0 +1,28 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+type SpinnerMode = 'determinate' | 'indeterminate';
+declare class ProgressSpinner {
+    readonly color: _angular_core.InputSignal<string>;
+    readonly mode: _angular_core.InputSignal<SpinnerMode>;
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly diameter: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly strokeWidth: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly _elementRef: ElementRef<any>;
+    readonly _actualStrokeWidth: _angular_core.Signal<number>;
+    _circleRadius(): number;
+    _viewBox(): string;
+    _strokeCircumference(): number;
+    _strokeDashOffset(): number | null;
+    _circleStrokeWidth(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressSpinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressSpinner, "ngs-progress-spinner", ["ngsProgressSpinner"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "diameter": { "alias": "diameter"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ProgressSpinnerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressSpinnerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ProgressSpinnerModule, never, [typeof ProgressSpinner], [typeof ProgressSpinner]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ProgressSpinnerModule>;
+}
+
+export { ProgressSpinner, ProgressSpinnerModule };
+export type { SpinnerMode };

package/types/ngstarter-ui-components-splash-screen.d.ts

@@ -0,0 +1,31 @@
+import * as _angular_core from '@angular/core';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare class SplashScreen {
+    private _store;
+    private _renderer;
+    private _elementRef;
+    private _router;
+    animationDuration: _angular_core.InputSignalWithTransform<number, unknown>;
+    hideDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    constructor();
+    ngOnInit(): void;
+    private _show;
+    private _hide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplashScreen, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplashScreen, "ngs-splash-screen", ["ngsSplashScreen"], { "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; }, {}, never, ["ngs-logo", "*"], true, never>;
+}
+
+interface SplashScreenState {
+    visible: boolean;
+}
+declare const SplashScreenStore: _angular_core.Type<{
+    visible: _angular_core.Signal<boolean>;
+    show: () => void;
+    hide: () => void;
+} & _ngrx_signals.StateSource<{
+    visible: boolean;
+}>>;
+
+export { SplashScreen, SplashScreenStore };
+export type { SplashScreenState };

package/types/ngstarter-ui-components-split.d.ts

@@ -0,0 +1,210 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef, InjectionToken, AfterViewInit, EnvironmentProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare class SplitPane implements OnDestroy {
+    private ngZone;
+    private renderer;
+    private split;
+    elRef: ElementRef<any>;
+    /**
+     * Order of the area. Used to maintain the order of areas when toggling their visibility.
+     * Toggling area visibility without specifying an `order` leads to weird behavior.
+     */
+    orderIn: _angular_core.InputSignalWithTransform<number | null, string | number | null>;
+    /**
+     * Size of the area in selected unit (percent/pixel).
+     * - Percent: All areas sizes should equal to `100`, If not, all areas will have the same size.
+     * - Pixel: An area with wildcard size (`size="*"`) is mandatory (only one) and
+     *   can't have `visible="false"` or `minSize`/`maxSize`/`lockSize` properties.
+     */
+    sizeIn: _angular_core.InputSignalWithTransform<number | null, string | number | null>;
+    /** Minimum pixel or percent size, should be equal to or smaller than provided `size`. */
+    minSizeIn: _angular_core.InputSignalWithTransform<number | null, string | number | null>;
+    /** Maximum pixel or percent size, should be equal to or larger than provided `size`. */
+    maxSizeIn: _angular_core.InputSignalWithTransform<number | null, string | number | null>;
+    /** Lock area size, same as `minSize`=`maxSize`=`size`. */
+    lockSizeIn: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Hide area visually but still present in the DOM, use `ngIf` to completely remove it. */
+    visibleIn: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show handle (three dots) on the gutter adjacent to this pane. */
+    withHandleIn: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private orderSig;
+    private sizeSig;
+    private minSizeSig;
+    private maxSizeSig;
+    private lockSizeSig;
+    private visibleSig;
+    private withHandleSig;
+    private transitionListener;
+    private readonly lockListeners;
+    constructor();
+    getOrder(): number | null;
+    getSize(): number | null;
+    setSize(v: number | null): void;
+    getMinSize(): number | null;
+    getMaxSize(): number | null;
+    isLocked(): boolean;
+    isVisible(): boolean;
+    hasHandle(): boolean;
+    setStyleOrder(value: number): void;
+    setStyleFlex(grow: number, shrink: number, basis: string, isMin: boolean, isMax: boolean): void;
+    lockEvents(): void;
+    unlockEvents(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitPane, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SplitPane, "ngs-split-pane, [ngs-split-pane]", ["ngsSplitPane"], { "orderIn": { "alias": "order"; "required": false; "isSignal": true; }; "sizeIn": { "alias": "size"; "required": false; "isSignal": true; }; "minSizeIn": { "alias": "minSize"; "required": false; "isSignal": true; }; "maxSizeIn": { "alias": "maxSize"; "required": false; "isSignal": true; }; "lockSizeIn": { "alias": "lockSize"; "required": false; "isSignal": true; }; "visibleIn": { "alias": "visible"; "required": false; "isSignal": true; }; "withHandleIn": { "alias": "withHandle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SplitPoint {
+    x: number;
+    y: number;
+}
+interface SplitArea {
+    component: SplitPane;
+    order: number;
+    size: number | null;
+    minSize: number | null;
+    maxSize: number | null;
+}
+interface SplitSnapshot {
+    gutterNum: number;
+    allAreasSizePixel: number;
+    allInvolvedAreasSizePercent: number;
+    lastSteppedOffset: number;
+    areasBeforeGutter: SplitAreaSnapshot[];
+    areasAfterGutter: SplitAreaSnapshot[];
+}
+interface SplitAreaSnapshot {
+    area: SplitArea;
+    sizePixelAtStart: number;
+    sizePercentAtStart: number;
+}
+interface SplitSideAbsorptionCapacity {
+    remain: number;
+    list: SplitAreaAbsorptionCapacity[];
+}
+interface SplitAreaAbsorptionCapacity {
+    areaSnapshot: SplitAreaSnapshot;
+    pixelAbsorb: number;
+    percentAfterAbsorption: number;
+    pixelRemain: number;
+}
+interface SplitOutputData {
+    gutterNum: number;
+    sizes: SplitOutputAreaSizes;
+}
+type SplitOutputAreaSizes = (number | '*')[];
+interface SplitDefaultOptions {
+    dir?: 'ltr' | 'rtl';
+    direction?: 'horizontal' | 'vertical';
+    unit?: 'percent' | 'pixel';
+    gutterDblClickDuration?: number;
+    gutterSize?: number;
+    gutterStep?: number;
+    restrictMove?: boolean;
+    useTransition?: boolean;
+}
+
+declare function getPointFromEvent(event: MouseEvent | TouchEvent): SplitPoint | null;
+declare function getElementPixelSize(elRef: ElementRef, direction: 'horizontal' | 'vertical'): number;
+declare function getInputPositiveNumber<T>(v: any, defaultValue: T): number | T;
+declare function isUserSizesValid(unit: 'percent' | 'pixel', sizes: number[]): boolean | number | void;
+declare function getAreaMinSize(a: SplitArea): number;
+declare function getAreaMaxSize(a: SplitArea): null | number;
+declare function getGutterSideAbsorptionCapacity(unit: 'percent' | 'pixel', sideAreas: SplitAreaSnapshot[], pixels: number, allAreasSizePixel: number): SplitSideAbsorptionCapacity;
+declare function getAreaAbsorptionCapacity(unit: 'percent' | 'pixel', areaSnapshot: SplitAreaSnapshot, pixels: number, allAreasSizePixel: number): SplitAreaAbsorptionCapacity | void;
+declare function getAreaAbsorptionCapacityPercent(areaSnapshot: SplitAreaSnapshot, pixels: number, allAreasSizePixel: number): SplitAreaAbsorptionCapacity | void;
+declare function getAreaAbsorptionCapacityPixel(areaSnapshot: SplitAreaSnapshot, pixels: number, containerSizePixel: number): SplitAreaAbsorptionCapacity | void;
+declare function updateAreaSize(unit: 'percent' | 'pixel', item: SplitAreaAbsorptionCapacity): void;
+
+/** Injection token that can be used to specify default split options. */
+declare const SPLIT_DEFAULT_OPTIONS: InjectionToken<SplitDefaultOptions>;
+/**
+ * Configures the default options for the split component.
+ * @param options The default options to use.
+ * @returns The environment providers.
+ */
+declare function provideSplit(options: SplitDefaultOptions): EnvironmentProviders;
+declare class Split implements AfterViewInit, OnDestroy {
+    shouldShowHandle(gutterIndex: number): boolean;
+    private ngZone;
+    private elRef;
+    private cdRef;
+    private renderer;
+    private isInit;
+    protected _defaultOptions: SplitDefaultOptions | null;
+    /** The split direction. */
+    direction: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /** The unit you want to specify area sizes. */
+    unit: _angular_core.InputSignal<"percent" | "pixel">;
+    /** Gutters's size (dragging elements) in pixels. */
+    gutterSize: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Gutter step while moving in pixels. */
+    gutterStep: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Set to true if you want to limit gutter move to adjacent areas only. */
+    restrictMove: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Add transition when toggling visibility using `visible` or `size` changes. */
+    useTransition: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Disable the dragging feature (remove cursor/image on gutters).
+     * `gutterClick`/`gutterDblClick` still emits.
+     */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Indicates the directionality of the areas. */
+    dir: _angular_core.InputSignal<"ltr" | "rtl">;
+    /**
+     * Milliseconds to detect a double click on a gutter. Set it around 300-500ms if
+     * you want to use `gutterDblClick` event.
+     */
+    gutterDblClickDuration: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Event emitted when drag starts. */
+    dragStart: _angular_core.OutputEmitterRef<SplitOutputData>;
+    /** Event emitted when drag ends. */
+    dragEnd: _angular_core.OutputEmitterRef<SplitOutputData>;
+    /** Event emitted when user clicks on a gutter. */
+    gutterClick: _angular_core.OutputEmitterRef<SplitOutputData>;
+    /** Event emitted when user double clicks on a gutter. */
+    gutterDblClick: _angular_core.OutputEmitterRef<SplitOutputData>;
+    /** Event emitted when transition ends (debounced). */
+    transitionEnd: _angular_core.OutputEmitterRef<SplitOutputAreaSizes>;
+    private transitionEndSubject;
+    private dragProgressSubject;
+    dragProgress$: Observable<SplitOutputData>;
+    private isDragging;
+    private dragListeners;
+    private snapshot;
+    private startPoint;
+    private endPoint;
+    readonly displayedAreas: SplitArea[];
+    private readonly hidedAreas;
+    private gutterEls;
+    protected isDraggingSignal: _angular_core.Signal<boolean>;
+    readonly isDraggingPublic: _angular_core.Signal<boolean>;
+    protected isInitSignal: _angular_core.Signal<boolean>;
+    constructor();
+    ngAfterViewInit(): void;
+    private getNbGutters;
+    addArea(component: SplitPane): void;
+    removeArea(component: SplitPane): void;
+    updateArea(component: SplitPane, resetOrders: boolean, resetSizes: boolean): void;
+    updateAreaInternal(component: SplitPane): void;
+    showArea(component: SplitPane): void;
+    hideArea(comp: SplitPane): void;
+    getVisibleAreaSizes(): SplitOutputAreaSizes;
+    setVisibleAreaSizes(sizes: SplitOutputAreaSizes): boolean;
+    private build;
+    private refreshStyleSizes;
+    _clickTimeout: number | null;
+    clickGutter(event: MouseEvent | TouchEvent, gutterNum: number): void;
+    startDragging(event: MouseEvent | TouchEvent, gutterOrder: number, gutterNum: number): void;
+    private dragEvent;
+    private stopDragging;
+    notify(type: 'start' | 'progress' | 'end' | 'click' | 'dblclick' | 'transitionEnd', gutterNum: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Split, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Split, "ngs-split", ["ngsSplit"], { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "gutterSize": { "alias": "gutterSize"; "required": false; "isSignal": true; }; "gutterStep": { "alias": "gutterStep"; "required": false; "isSignal": true; }; "restrictMove": { "alias": "restrictMove"; "required": false; "isSignal": true; }; "useTransition": { "alias": "useTransition"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "gutterDblClickDuration": { "alias": "gutterDblClickDuration"; "required": false; "isSignal": true; }; }, { "dragStart": "dragStart"; "dragEnd": "dragEnd"; "gutterClick": "gutterClick"; "gutterDblClick": "gutterDblClick"; "transitionEnd": "transitionEnd"; }, never, ["*"], true, never>;
+}
+
+export { SPLIT_DEFAULT_OPTIONS, Split, SplitPane, getAreaAbsorptionCapacity, getAreaAbsorptionCapacityPercent, getAreaAbsorptionCapacityPixel, getAreaMaxSize, getAreaMinSize, getElementPixelSize, getGutterSideAbsorptionCapacity, getInputPositiveNumber, getPointFromEvent, isUserSizesValid, provideSplit, updateAreaSize };
+export type { SplitArea, SplitAreaAbsorptionCapacity, SplitAreaSnapshot, SplitDefaultOptions, SplitOutputAreaSizes, SplitOutputData, SplitPoint, SplitSideAbsorptionCapacity, SplitSnapshot };

package/types/ngstarter-ui-components-stepper.d.ts

@@ -0,0 +1,44 @@
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { CdkStep, CdkStepper, StepperOrientation, CdkStepperNext, CdkStepperPrevious } from '@angular/cdk/stepper';
+
+declare class StepLabel {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepLabel, "[ngsStepLabel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class Step extends CdkStep {
+    stepLabel: StepLabel;
+    constructor(stepper: Stepper);
+    static ɵfac: i0.ɵɵFactoryDeclaration<Step, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Step, "ngs-step", ["ngsStep"], {}, {}, ["stepLabel"], ["*"], true, never>;
+}
+
+declare class Stepper extends CdkStepper {
+    headerPosition: i0.InputSignal<"top" | "bottom">;
+    labelPosition: i0.InputSignal<"top" | "bottom">;
+    private _stepperOrientation;
+    get orientation(): StepperOrientation;
+    set orientation(value: StepperOrientation);
+    readonly stepItems: i0.Signal<readonly Step[]>;
+    readonly _stepLabels: i0.Signal<readonly StepLabel[]>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Stepper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Stepper, "ngs-stepper", ["ngsStepper"], { "headerPosition": { "alias": "headerPosition"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; }, {}, ["stepItems", "_stepLabels"], never, true, never>;
+}
+
+declare class StepperNext extends CdkStepperNext {
+    type: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperNext, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepperNext, "button[ngsStepperNext]", never, {}, {}, never, never, true, never>;
+}
+
+declare class StepperPrevious extends CdkStepperPrevious {
+    type: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperPrevious, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepperPrevious, "button[ngsStepperPrevious]", never, {}, {}, never, never, true, never>;
+}
+
+export { Step, StepLabel, Stepper, StepperNext, StepperPrevious };

package/types/ngstarter-ui-components-suggestions.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@ngstarter-ui/components/core';
+
+declare class Suggestions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Suggestions, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Suggestions, "ngs-suggestions", ["ngsSuggestions"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class Suggestion {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Suggestion, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Suggestion, "ngs-suggestion,[ngs-suggestion]", ["ngsSuggestion"], {}, {}, never, ["[ngsSuggestionIcon]", "[ngsSuggestionThumb]", "*"], true, [{ directive: typeof i1.Ripple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SuggestionBlock {
+    heading: i0.InputSignal<unknown>;
+    showDivider: i0.InputSignalWithTransform<boolean, unknown>;
+    inline: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionBlock, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SuggestionBlock, "ngs-suggestion-block", ["ngsSuggestionBlock"], { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "showDivider": { "alias": "showDivider"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SuggestionIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SuggestionIconDirective, "[ngsSuggestionIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SuggestionThumbDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionThumbDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SuggestionThumbDirective, "[ngsSuggestionThumb]", never, {}, {}, never, never, true, never>;
+}
+
+export { Suggestion, SuggestionBlock, SuggestionIconDirective, SuggestionThumbDirective, Suggestions };