@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-phone-input.d.ts

@@ -0,0 +1,103 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, DoCheck, OnDestroy, ElementRef, PipeTransform } from '@angular/core';
+import { NgControl, NgForm, FormGroupDirective, UntypedFormControl } from '@angular/forms';
+import { ErrorStateMatcher } from '@ngstarter-ui/components/core';
+import { FormFieldControl } from '@ngstarter-ui/components/form-field';
+import { PhoneNumber, CountryCode } from 'libphonenumber-js';
+import { Subject } from 'rxjs';
+
+interface Country {
+    name: string;
+    shortCode: string;
+    phoneCode: string;
+}
+
+type PhoneNumberFormat = 'default' | 'national' | 'international';
+
+declare class PhoneInput implements OnInit, AfterViewInit, DoCheck, OnDestroy, FormFieldControl<any> {
+    ngControl: NgControl;
+    private _destroyRef;
+    private _changeDetectorRef;
+    private countryCodeData;
+    private _focusMonitor;
+    private _elementRef;
+    private _errorStateMatcher;
+    private _parentForm;
+    static nextId: number;
+    readonly menuSearchInput: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly focusable: _angular_core.Signal<ElementRef<any>>;
+    focused: boolean;
+    private _focused;
+    errorState: boolean;
+    private _errorState;
+    id: string;
+    private _id;
+    placeholder: string;
+    empty: boolean;
+    shouldLabelFloat: boolean;
+    private _shouldLabelFloat;
+    private _empty;
+    readonly countryChanged: _angular_core.OutputEmitterRef<Country>;
+    stateChanges: Subject<void>;
+    describedBy: string;
+    phoneNumber?: string;
+    allCountries: Country[];
+    preferredCountriesInDropDown: Country[];
+    selectedCountry: _angular_core.WritableSignal<Country | null>;
+    numberInstance?: PhoneNumber;
+    value: any;
+    searchCriteria?: string;
+    private _previousFormattedNumber?;
+    onTouched: () => void;
+    propagateChange: (_: any) => void;
+    autocomplete: _angular_core.InputSignal<AutoFill>;
+    errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher>;
+    onlyCountries: _angular_core.InputSignal<string[]>;
+    preferredCountries: _angular_core.InputSignal<string[]>;
+    format: _angular_core.InputSignal<PhoneNumberFormat>;
+    defaultSelectedCountryCode: _angular_core.InputSignal<string>;
+    readonly _placeholder: _angular_core.InputSignal<string>;
+    set required(value: boolean);
+    get required(): boolean;
+    private _required;
+    phoneDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private _disabled;
+    private _compositeDisabled;
+    disabled: boolean;
+    constructor(ngControl: NgControl, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _defaultErrorStateMatcher: ErrorStateMatcher);
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    updateErrorState(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onPhoneNumberChange(): void;
+    onCountrySelect(country: Country, el: any): void;
+    getCountry(shortCode: CountryCode): Country;
+    onInputKeyPress(event: any): void;
+    protected fetchCountryData(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    setDescribedByIds(ids: string[]): void;
+    focus(): void;
+    onContainerClick(event: MouseEvent): void;
+    reset(): void;
+    private get formattedPhoneNumber();
+    private formatAsYouTypeIfEnabled;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneInput, [{ optional: true; self: true; }, { optional: true; }, { optional: true; }, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneInput, "ngs-phone-input", ["ngsPhoneInput"], { "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "onlyCountries": { "alias": "onlyCountries"; "required": false; "isSignal": true; }; "preferredCountries": { "alias": "preferredCountries"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "defaultSelectedCountryCode": { "alias": "defaultSelectedCountryCode"; "required": false; "isSignal": true; }; "_placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; }; "phoneDisabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "countryChanged": "countryChanged"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare const phoneValidator: (control: UntypedFormControl) => {
+    invalidPhone: boolean;
+} | null;
+
+declare class SearchPipe implements PipeTransform {
+    transform(countries: Country[], searchCriteria?: string): Country[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SearchPipe, "search", true>;
+}
+
+export { PhoneInput, SearchPipe, phoneValidator };

package/types/ngstarter-ui-components-pin-input.d.ts

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { ControlValueAccessor, FormGroup } from '@angular/forms';
+
+declare class PinInputDirective implements OnInit {
+    private _elementRef;
+    private _renderer;
+    private _placeholder;
+    index: _angular_core.InputSignal<number | undefined>;
+    acceptOnly: _angular_core.InputSignal<RegExp | undefined>;
+    readonly valuePaste: _angular_core.OutputEmitterRef<string>;
+    get api(): {
+        focus: () => void;
+        nativeElement: any;
+    };
+    ngOnInit(): void;
+    protected _handleFocus(): void;
+    protected _handleBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PinInputDirective, "[ngsPinInput]", ["ngsPinInput"], { "index": { "alias": "index"; "required": false; "isSignal": true; }; "acceptOnly": { "alias": "acceptOnly"; "required": false; "isSignal": true; }; }, { "valuePaste": "valuePaste"; }, never, never, true, never>;
+}
+
+declare class PinInput implements ControlValueAccessor, OnInit {
+    private _fb;
+    readonly inputs: _angular_core.Signal<readonly PinInputDirective[]>;
+    length: _angular_core.InputSignalWithTransform<number, unknown>;
+    placeholder: _angular_core.InputSignal<string>;
+    acceptOnly: _angular_core.InputSignal<RegExp>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected form: FormGroup;
+    private _disabled;
+    protected isDisabled: _angular_core.Signal<boolean>;
+    onChange: any;
+    onTouched: any;
+    get controls(): any[];
+    ngOnInit(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    protected _valuePaste(event: ClipboardEvent): void;
+    protected _handleKeyDown(event: KeyboardEvent): void;
+    protected _handleKeyUp(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PinInput, "ngs-pin-input", ["ngsPinInput"], { "length": { "alias": "length"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "acceptOnly": { "alias": "acceptOnly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { PinInput };

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

@@ -0,0 +1,94 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import * as _ngstarter_ui_components_popover from '@ngstarter-ui/components/popover';
+import * as _ngstarter_ui_components_overlay from '@ngstarter-ui/components/overlay';
+import { OverlayPosition } from '@ngstarter-ui/components/overlay';
+import { FlexibleConnectedPositionStrategyOrigin } from '@angular/cdk/overlay';
+
+declare class PopoverContent {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverContent, "[ngsPopoverContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class Popover {
+    readonly trigger: _ngstarter_ui_components_popover.PopoverTriggerFor | null;
+    readonly templateRef: _angular_core.Signal<TemplateRef<any>>;
+    readonly content: _angular_core.Signal<PopoverContent | undefined>;
+    readonly _context: _angular_core.WritableSignal<any>;
+    readonly _positionClasses: _angular_core.WritableSignal<string[]>;
+    _setContext(context: any): void;
+    _setPositionClasses(classes: string[]): void;
+    open(): void;
+    close(): void;
+    isOpen(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Popover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Popover, "ngs-popover", ["ngsPopover"], {}, {}, ["content"], ["*"], true, never>;
+}
+
+type PopoverTrigger = 'click' | 'hover';
+type PopoverPosition = OverlayPosition;
+interface PopoverTriggerFor {
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+}
+declare const POPOVER_TRIGGER: InjectionToken<PopoverTriggerFor>;
+
+declare class PopoverTriggerForDirective implements OnInit, OnDestroy, PopoverTriggerFor {
+    private _overlay;
+    private _elementRef;
+    private _directionality;
+    private _viewContainerRef;
+    private _injector;
+    private _popoverPortal;
+    private _overlayRef;
+    private _destroyRef;
+    private _openTimeout;
+    private _closeTimeout;
+    private _closeDelay;
+    popover: _angular_core.InputSignal<TemplateRef<any> | Popover>;
+    popoverContext: _angular_core.InputSignal<any>;
+    trigger: _angular_core.InputSignal<PopoverTrigger>;
+    position: _angular_core.InputSignal<_ngstarter_ui_components_overlay.OverlayPosition>;
+    delay: _angular_core.InputSignalWithTransform<number, unknown>;
+    origin: _angular_core.InputSignal<FlexibleConnectedPositionStrategyOrigin | undefined>;
+    closeOnOriginClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeOnOriginMouseLeave: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hasBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private _closed;
+    constructor();
+    protected _handleClick(): void;
+    protected _handleMouseover(): void;
+    protected _handleMouseout(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get api(): PopoverTriggerFor;
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+    private _destroyOverlay;
+    private _subscribeToOutsideClicks;
+    private _getPopoverContentPortal;
+    private _getOverlayConfig;
+    private _getOverlayPositionStrategy;
+    private _getOverlayPositions;
+    private _setType;
+    private _subscribeToHostMouseleave;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverTriggerForDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverTriggerForDirective, "[ngsPopoverTriggerFor]", ["ngsPopoverTriggerFor"], { "popover": { "alias": "ngsPopoverTriggerFor"; "required": true; "isSignal": true; }; "popoverContext": { "alias": "ngsPopoverContext"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "origin": { "alias": "origin"; "required": false; "isSignal": true; }; "closeOnOriginClick": { "alias": "closeOnOriginClick"; "required": false; "isSignal": true; }; "closeOnOriginMouseLeave": { "alias": "closeOnOriginMouseLeave"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class PopoverOriginDirective {
+    private _elementRef;
+    get api(): {
+        nativeElement: () => any;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverOriginDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverOriginDirective, "[ngsPopoverOrigin]", ["ngsPopoverOrigin"], {}, {}, never, never, true, never>;
+}
+
+export { POPOVER_TRIGGER, Popover, PopoverContent, PopoverOriginDirective, PopoverTriggerForDirective };
+export type { PopoverPosition, PopoverTrigger, PopoverTriggerFor };

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

@@ -0,0 +1,30 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy } from '@angular/core';
+
+type ProgressBarMode = 'determinate' | 'indeterminate' | 'buffer' | 'query';
+declare class ProgressBar implements AfterViewInit, OnDestroy {
+    private readonly _elementRef;
+    private readonly _ngZone;
+    private readonly _renderer;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly bufferValue: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly mode: _angular_core.InputSignal<ProgressBarMode>;
+    readonly animationEnd: _angular_core.OutputEmitterRef<{
+        value: number;
+    }>;
+    private _cleanupTransitionEnd?;
+    readonly isIndeterminate: _angular_core.Signal<boolean>;
+    readonly primaryBarTransform: _angular_core.Signal<string>;
+    readonly bufferBarTransform: _angular_core.Signal<string>;
+    /** @deprecated use bufferBarTransform instead */
+    readonly bufferBarFlexBasis: _angular_core.Signal<string>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _transitionendHandler;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBar, "ngs-progress-bar", ["ngsProgressBar"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "bufferValue": { "alias": "bufferValue"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "animationEnd": "animationEnd"; }, never, never, true, never>;
+}
+
+export { ProgressBar };
+export type { ProgressBarMode };

package/types/ngstarter-ui-components-radio-card.d.ts

@@ -0,0 +1,37 @@
+import * as i0 from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class RadioCardGroup implements ControlValueAccessor {
+    readonly value: i0.WritableSignal<any>;
+    readonly disabled: i0.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    selectValue(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCardGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCardGroup, "ngs-radio-card-group", ["ngsRadioCardGroup"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class RadioCard {
+    value: i0.InputSignal<any>;
+    protected parentGroup: RadioCardGroup;
+    readonly isSelected: i0.Signal<boolean>;
+    selectCard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCard, "ngs-radio-card", ["ngsRadioCard"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["ngs-radio-card-title", "*"], true, never>;
+}
+
+declare class RadioCardTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCardTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCardTitle, "ngs-radio-card-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RadioCardContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCardContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCardContent, "ngs-radio-card-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { RadioCard, RadioCardContent, RadioCardGroup, RadioCardTitle };

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

@@ -0,0 +1,45 @@
+import * as _angular_core from '@angular/core';
+import { AfterContentInit, OnInit, ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class RadioGroup implements ControlValueAccessor, AfterContentInit {
+    readonly _radios: _angular_core.Signal<readonly any[]>;
+    disabled: _angular_core.ModelSignal<boolean>;
+    name: _angular_core.InputSignal<string | undefined>;
+    value: _angular_core.ModelSignal<any>;
+    readonly change: _angular_core.OutputEmitterRef<any>;
+    constructor();
+    _onChange: (value: any) => void;
+    _onTouched: () => void;
+    ngAfterContentInit(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    _emitChangeEvent(value: any): void;
+    private _updateSelectedRadioFromValue;
+    private _markRadiosForCheck;
+    _onRadioClick(radio: RadioButton): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroup, "ngs-radio-group", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "value": "valueChange"; "change": "change"; }, ["_radios"], ["*"], true, never>;
+}
+
+declare class RadioButton implements OnInit {
+    radioGroup: RadioGroup;
+    private _changeDetectorRef;
+    id: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<any>;
+    name: _angular_core.InputSignal<string | undefined>;
+    checked: _angular_core.ModelSignal<boolean>;
+    disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    disabled: _angular_core.Signal<boolean>;
+    readonly change: _angular_core.OutputEmitterRef<any>;
+    constructor(radioGroup: RadioGroup, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    _onInputClick(event: Event): void;
+    _markForCheck(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioButton, [{ optional: true; }, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioButton, "ngs-radio-button", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+
+export { RadioButton, RadioGroup };

package/types/ngstarter-ui-components-rail-nav.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+
+interface RailNavAPI {
+    getActiveKey: () => any;
+    activateItem: (key: any) => void;
+    isActive: (key: any) => boolean;
+}
+interface RailNavComponent {
+    api: RailNavAPI;
+}
+
+declare class RailNav implements OnInit {
+    activeKey: i0.InputSignal<unknown>;
+    private _activeKey;
+    readonly api: RailNavAPI;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RailNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RailNav, "ngs-rail-nav", ["ngsRailNav"], { "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class RailNavItem {
+    protected _railNav: RailNavComponent;
+    key: i0.InputSignal<string>;
+    get isActive(): boolean;
+    click(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RailNavItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RailNavItem, "ngs-rail-nav-item,[ngs-rail-nav-item]", ["ngsRailNavItem"], { "key": { "alias": "key"; "required": false; "isSignal": true; }; }, {}, never, ["[ngsRailNavItemIcon]", "*"], true, never>;
+}
+
+declare class RailNavItemIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RailNavItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RailNavItemIconDirective, "[ngsRailNavItemIcon]", never, {}, {}, never, never, true, never>;
+}
+
+export { RailNav, RailNavItem, RailNavItemIconDirective };

package/types/ngstarter-ui-components-resizable-container.d.ts

@@ -0,0 +1,25 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef } from '@angular/core';
+
+declare class ResizableContainer implements OnInit {
+    private _renderer;
+    private _elementRef;
+    private _cdr;
+    private _ngZone;
+    private _destroyRef;
+    private _document;
+    private _resizing;
+    private _maxWidth;
+    private _clientX;
+    private _initialWidth;
+    readonly handlerRef: _angular_core.Signal<ElementRef<any>>;
+    minWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly resized: _angular_core.OutputEmitterRef<{
+        width: number;
+    }>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizableContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResizableContainer, "ngs-resizable-container", ["ngsResizableContainer"], { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; }, { "resized": "resized"; }, never, ["*"], true, never>;
+}
+
+export { ResizableContainer };

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

@@ -0,0 +1,34 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, Injector } from '@angular/core';
+import { OverlayRef, Overlay } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+
+declare class ScreenLoader {
+    opened: i0.InputSignalWithTransform<boolean, unknown>;
+    message: i0.InputSignal<string | TemplateRef<any> | null>;
+    protected isTemplateRef(value: any): value is TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenLoader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScreenLoader, "ngs-screen-loader", ["ngsScreenLoader"], { "opened": { "alias": "opened"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScreenLoaderRef {
+    private overlayRef;
+    private readonly _afterOpened;
+    private readonly _afterClosed;
+    constructor(overlayRef: OverlayRef);
+    close(): void;
+    afterOpened(): Observable<void>;
+    afterClosed(): Observable<void>;
+    _notifyOpened(): void;
+}
+
+declare class ScreenLoaderService {
+    private overlay;
+    private injector;
+    constructor(overlay: Overlay, injector: Injector);
+    open(message: string | TemplateRef<any>): ScreenLoaderRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenLoaderService>;
+}
+
+export { ScreenLoader, ScreenLoaderRef, ScreenLoaderService };

package/types/ngstarter-ui-components-scroll-spy.d.ts

@@ -0,0 +1,63 @@
+import * as i0 from '@angular/core';
+import { OnInit, AfterContentInit, InjectionToken } from '@angular/core';
+
+declare class ScrollSpyOn implements OnInit {
+    private _parent;
+    private _elementRef;
+    private _renderer;
+    private _document;
+    targetId: i0.InputSignal<string>;
+    ngOnInit(): void;
+    protected get isActive(): boolean;
+    protected _handleClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyOn, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollSpyOn, "ngs-scroll-spy-on,[ngs-scroll-spy-on]", ["ngsScrollSpyOn"], { "targetId": { "alias": "targetId"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollSpyNav implements AfterContentInit {
+    private document;
+    private cdr;
+    private platformId;
+    private zone;
+    private destroyRef;
+    private panelBody;
+    private layoutBody;
+    readonly _items: i0.Signal<readonly ScrollSpyOn[]>;
+    private threshold;
+    protected _activeId: string;
+    private scrollContainer;
+    ngAfterContentInit(): void;
+    get activeId(): string;
+    scrollTo(targetId: string): void;
+    private _findActiveItem;
+    private _elementIsVisibleInViewport;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollSpyNav, "ngs-scroll-spy-nav,[ngs-scroll-spy-nav]", ["ngsScrollSpyNav"], {}, {}, ["_items"], ["ngs-scroll-spy-title,[ngs-scroll-spy-title]", "*", "ngs-scroll-spy-back-to-top,[ngs-scroll-spy-back-to-top]"], true, never>;
+}
+
+declare class ScrollSpyTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollSpyTitle, "ngs-scroll-spy-title,[ngs-scroll-spy-title]", ["ngsScrollSpyTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollSpyContainerDirective {
+    private elementRef;
+    getScrollContainer(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollSpyContainerDirective, "[ngsScrollSpyContainer]", ["ngsScrollSpyContainer"], {}, {}, never, never, true, never>;
+}
+
+declare class ScrollSpyBackToTop {
+    private platformId;
+    private document;
+    private panelBody;
+    private layoutBody;
+    private scrollContainer;
+    scrollToTop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyBackToTop, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollSpyBackToTop, "ngs-scroll-spy-back-to-top,[ngs-scroll-spy-back-to-top]", ["ngsScrollSpyBackToTop"], {}, {}, never, ["*"], true, never>;
+}
+
+declare const SCROLL_SPY_NAV: InjectionToken<unknown>;
+
+export { SCROLL_SPY_NAV, ScrollSpyBackToTop, ScrollSpyContainerDirective, ScrollSpyNav, ScrollSpyOn, ScrollSpyTitle };

package/types/ngstarter-ui-components-scrollbar-area.d.ts

@@ -0,0 +1,67 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, EventEmitter } from '@angular/core';
+
+declare class ScrollbarArea {
+    private readonly platformId;
+    private readonly elRef;
+    private readonly zone;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly router;
+    readonly scrollableContentRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollTrackRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollThumbRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollTrackXRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollThumbXRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollbarWidth: _angular_core.InputSignal<string>;
+    readonly autoHide: _angular_core.InputSignal<boolean>;
+    readonly absolute: _angular_core.InputSignal<boolean>;
+    readonly scrolled: EventEmitter<Event>;
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly isHovering: _angular_core.WritableSignal<boolean>;
+    private readonly scrollTop;
+    private readonly scrollLeft;
+    private readonly contentScrollHeight;
+    private readonly contentScrollWidth;
+    private readonly contentClientHeight;
+    private readonly contentClientWidth;
+    private readonly trackClientHeight;
+    private readonly trackClientWidth;
+    private readonly showDueToActivity;
+    readonly hasScrollY: _angular_core.Signal<boolean>;
+    readonly scrollRatioY: _angular_core.Signal<number>;
+    readonly minThumbHeight = 20;
+    readonly thumbHeight: _angular_core.Signal<number>;
+    readonly maxScrollTop: _angular_core.Signal<number>;
+    readonly maxThumbTop: _angular_core.Signal<number>;
+    readonly thumbTop: _angular_core.Signal<number>;
+    readonly hasScrollX: _angular_core.Signal<boolean>;
+    readonly scrollRatioX: _angular_core.Signal<number>;
+    readonly minThumbWidth = 20;
+    readonly thumbWidth: _angular_core.Signal<number>;
+    readonly maxScrollLeft: _angular_core.Signal<number>;
+    readonly maxThumbLeft: _angular_core.Signal<number>;
+    readonly thumbLeft: _angular_core.Signal<number>;
+    readonly hasAnyScroll: _angular_core.Signal<boolean>;
+    readonly isVisible: _angular_core.Signal<boolean>;
+    readonly isInteractive: _angular_core.Signal<boolean>;
+    private isInitialized;
+    private eventsSubscription;
+    private observersSubscription;
+    private hideTimeout;
+    constructor();
+    private initializeComponentLogic;
+    private raf;
+    private setupStyleEffects;
+    private setupObservers;
+    private setupEventStreams;
+    private scheduleHide;
+    private clearHideTimeout;
+    private updateDimensions;
+    private cleanup;
+    private setupRouteChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollbarArea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollbarArea, "ngs-scrollbar-area", ["ngsScrollbarArea"], { "scrollbarWidth": { "alias": "scrollbarWidth"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "absolute": { "alias": "absolute"; "required": false; "isSignal": true; }; }, { "scrolled": "scrolled"; }, never, ["*"], true, never>;
+}
+
+export { ScrollbarArea };