@ngstarter-ui/components 1.0.21

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

@@ -0,0 +1,384 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef, Type, OnInit, ElementRef, InjectionToken, Provider } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { FormFieldControl } from '@ngstarter-ui/components/form-field';
+
+declare class DatepickerActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerActions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatepickerActions, "ngs-datepicker-actions", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class DateRange<D> {
+    /** The start date of the range. */
+    readonly start: D | null;
+    /** The end date of the range. */
+    readonly end: D | null;
+    constructor(
+    /** The start date of the range. */
+    start: D | null, 
+    /** The end date of the range. */
+    end: D | null);
+}
+
+interface DatepickerPreset<D> {
+    label: string;
+    value: D | DateRange<D> | null;
+}
+
+declare class Datepicker<D> implements OnDestroy {
+    private _overlay;
+    private _viewContainerRef;
+    readonly _portalTemplate: _angular_core.Signal<TemplateRef<any>>;
+    readonly actions: _angular_core.Signal<DatepickerActions | undefined>;
+    startAt: _angular_core.InputSignal<D | null>;
+    calendarHeaderComponent: _angular_core.InputSignal<Type<any> | null>;
+    quickPresets: _angular_core.InputSignal<DatepickerPreset<D>[]>;
+    showQuickPresets: _angular_core.InputSignal<boolean>;
+    _datepickerInput: any;
+    _selected: _angular_core.WritableSignal<D | null>;
+    _isAbove: _angular_core.WritableSignal<boolean>;
+    private _overlayRef;
+    ngOnDestroy(): void;
+    _registerInput(input: any): void;
+    open(): void;
+    close(): void;
+    _select(date: D): void;
+    _selectPreset(preset: DatepickerPreset<D>): void;
+    apply(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Datepicker<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Datepicker<any>, "ngs-datepicker", ["ngsDatepicker"], { "startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "calendarHeaderComponent": { "alias": "calendarHeaderComponent"; "required": false; "isSignal": true; }; "quickPresets": { "alias": "quickPresets"; "required": false; "isSignal": true; }; "showQuickPresets": { "alias": "showQuickPresets"; "required": false; "isSignal": true; }; }, {}, ["actions"], ["ngs-datepicker-actions"], true, never>;
+}
+
+declare class DatepickerApply {
+    _datepicker: any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerApply, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DatepickerApply, "[ngsDatepickerApply]", never, {}, {}, never, never, true, never>;
+}
+declare class DatepickerCancel {
+    _datepicker: any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerCancel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DatepickerCancel, "[ngsDatepickerCancel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DateRangePicker<D> implements OnDestroy {
+    private _overlay;
+    private _viewContainerRef;
+    private _dateAdapter;
+    readonly startAt: _angular_core.InputSignal<D | null>;
+    readonly calendarHeaderComponent: _angular_core.InputSignal<Type<any> | null>;
+    readonly quickPresets: _angular_core.InputSignal<DatepickerPreset<D>[] | null>;
+    readonly showQuickPresets: _angular_core.InputSignal<boolean>;
+    readonly _portalTemplate: _angular_core.Signal<TemplateRef<any>>;
+    readonly actions: _angular_core.Signal<DatepickerActions | undefined>;
+    _datepickerInput: any;
+    _selectedRange: _angular_core.WritableSignal<DateRange<D>>;
+    _isAbove: _angular_core.WritableSignal<boolean>;
+    readonly _effectivePresets: _angular_core.Signal<DatepickerPreset<D>[]>;
+    private _overlayRef;
+    ngOnDestroy(): void;
+    _registerInput(input: any): void;
+    open(): void;
+    close(): void;
+    _select(date: D): void;
+    _selectPreset(preset: DatepickerPreset<D>): void;
+    private _updateSelectedRange;
+    apply(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangePicker<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangePicker<any>, "ngs-date-range-picker", ["ngsDateRangePicker"], { "startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "calendarHeaderComponent": { "alias": "calendarHeaderComponent"; "required": false; "isSignal": true; }; "quickPresets": { "alias": "quickPresets"; "required": false; "isSignal": true; }; "showQuickPresets": { "alias": "showQuickPresets"; "required": false; "isSignal": true; }; }, {}, ["actions"], ["ngs-datepicker-actions"], true, never>;
+}
+
+declare class DatepickerInput<D> implements ControlValueAccessor, OnDestroy, OnInit {
+    private _elementRef;
+    private _formField;
+    private _dateAdapter;
+    readonly ngsDatepicker: _angular_core.InputSignal<Datepicker<D>>;
+    _value: D | null;
+    _onChange: (value: any) => void;
+    _onTouched: () => void;
+    readonly _valueChange: Subject<D | null>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: D | null): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    _onInput(value: string): void;
+    private _formatValue;
+    getConnectedOverlayOrigin(): ElementRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerInput<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DatepickerInput<any>, "input[ngsDatepicker]", never, { "ngsDatepicker": { "alias": "ngsDatepicker"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class StartDate<D> {
+    private _elementRef;
+    private _dateAdapter;
+    _rangeInput: DateRangeInput<D>;
+    _onInput(value: string): void;
+    _formatValue(value: D | null): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    isEmpty(): boolean;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StartDate<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StartDate<any>, "input[ngsStartDate]", never, {}, {}, never, never, true, never>;
+}
+declare class EndDate<D> {
+    private _elementRef;
+    private _dateAdapter;
+    _rangeInput: DateRangeInput<D>;
+    _onInput(value: string): void;
+    _formatValue(value: D | null): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    isEmpty(): boolean;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EndDate<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EndDate<any>, "input[ngsEndDate]", never, {}, {}, never, never, true, never>;
+}
+declare class DateRangeInput<D> implements OnDestroy, OnInit, FormFieldControl<DateRange<D>> {
+    private _elementRef;
+    private _formField;
+    readonly rangePicker: _angular_core.InputSignal<DateRangePicker<D>>;
+    readonly separator: _angular_core.InputSignal<string>;
+    readonly ngControl: NgControl | null;
+    _startInput: _angular_core.Signal<StartDate<any> | undefined>;
+    _endInput: _angular_core.Signal<EndDate<any> | undefined>;
+    _value: DateRange<D> | null;
+    get value(): DateRange<D> | null;
+    private _focused;
+    get focused(): boolean;
+    private _empty;
+    get empty(): boolean;
+    private _shouldLabelFloat;
+    get shouldLabelFloat(): boolean;
+    readonly stateChanges: Subject<void>;
+    private _inputStateChanges;
+    id: string;
+    placeholder: string;
+    required: boolean;
+    disabled: boolean;
+    errorState: boolean;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    _startUpdated(date: D | null): void;
+    _endUpdated(date: D | null): void;
+    _rangeUpdated(range: DateRange<D>): void;
+    _handleFocus(): void;
+    _handleBlur(): void;
+    _inputUpdated(): void;
+    getConnectedOverlayOrigin(): ElementRef;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangeInput<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangeInput<any>, "ngs-date-range-input", never, { "rangePicker": { "alias": "rangePicker"; "required": true; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, ["_startInput", "_endInput"], ["input[ngsStartDate]", "input[ngsEndDate]"], true, never>;
+}
+
+declare class DatepickerToggleIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerToggleIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DatepickerToggleIcon, "[ngsDatepickerToggleIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DatepickerToggle<D> {
+    private _intl;
+    private _formField;
+    readonly for: _angular_core.InputSignal<Datepicker<D> | DateRangePicker<D>>;
+    readonly customIcon: _angular_core.Signal<DatepickerToggleIcon | undefined>;
+    _open(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerToggle<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatepickerToggle<any>, "ngs-datepicker-toggle", ["ngsDatepickerToggle"], { "for": { "alias": "for"; "required": true; "isSignal": true; }; }, {}, ["customIcon"], ["[ngsDatepickerToggleIcon]"], true, never>;
+}
+
+declare class Calendar<D> {
+    private _dateAdapter;
+    private _intl;
+    readonly startAt: _angular_core.InputSignal<D | null>;
+    readonly selected: _angular_core.InputSignal<D | DateRange<D> | null>;
+    readonly minDate: _angular_core.InputSignal<D | null>;
+    readonly maxDate: _angular_core.InputSignal<D | null>;
+    readonly headerComponent: _angular_core.InputSignal<Type<any> | null>;
+    readonly selectedChange: _angular_core.OutputEmitterRef<D>;
+    readonly yearSelected: _angular_core.OutputEmitterRef<D>;
+    readonly monthSelected: _angular_core.OutputEmitterRef<D>;
+    activeDate: _angular_core.WritableSignal<D>;
+    constructor();
+    currentView: _angular_core.WritableSignal<"month" | "year" | "multi-year">;
+    readonly _selectedDate: _angular_core.Signal<D | null>;
+    readonly periodButtonText: _angular_core.Signal<string>;
+    prevPage(): void;
+    nextPage(): void;
+    toggleView(): void;
+    _monthSelectedInYearView(date: D): void;
+    _yearSelectedInMultiYearView(date: D): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Calendar<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Calendar<any>, "ngs-calendar", ["ngsCalendar"], { "startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "headerComponent": { "alias": "headerComponent"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; }, never, never, true, never>;
+}
+
+declare class MonthView<D> {
+    private _dateAdapter;
+    readonly activeDate: _angular_core.InputSignal<D>;
+    readonly selected: _angular_core.InputSignal<D | DateRange<D> | null>;
+    readonly minDate: _angular_core.InputSignal<D | null>;
+    readonly maxDate: _angular_core.InputSignal<D | null>;
+    readonly selectedChange: _angular_core.OutputEmitterRef<D>;
+    readonly hoveredDate: _angular_core.WritableSignal<D | null>;
+    readonly weekdays: _angular_core.Signal<string[]>;
+    readonly weeks: _angular_core.Signal<{
+        date: D | null;
+        label: string;
+        selected: boolean;
+        current: boolean;
+        inRange: boolean;
+        rangeStart: boolean;
+        rangeEnd: boolean;
+    }[][]>;
+    selectDate(date: D | null): void;
+    handleHover(date: D | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MonthView<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MonthView<any>, "ngs-month-view", never, { "activeDate": { "alias": "activeDate"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+declare class YearView<D> {
+    private _dateAdapter;
+    readonly activeDate: _angular_core.InputSignal<D>;
+    readonly selected: _angular_core.InputSignal<D | null>;
+    readonly monthSelected: _angular_core.OutputEmitterRef<D>;
+    readonly months: _angular_core.Signal<{
+        index: number;
+        label: string;
+        selected: boolean;
+        current: boolean;
+    }[][]>;
+    selectMonth(month: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YearView<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YearView<any>, "ngs-year-view", never, { "activeDate": { "alias": "activeDate"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "monthSelected": "monthSelected"; }, never, never, true, never>;
+}
+
+declare class MultiYearView<D> {
+    private _dateAdapter;
+    readonly activeDate: _angular_core.InputSignal<D>;
+    readonly selected: _angular_core.InputSignal<D | null>;
+    readonly yearSelected: _angular_core.OutputEmitterRef<D>;
+    readonly years: _angular_core.Signal<{
+        value: number;
+        label: string;
+        selected: boolean;
+        current: boolean;
+    }[][]>;
+    selectYear(year: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiYearView<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiYearView<any>, "ngs-multi-year-view", never, { "activeDate": { "alias": "activeDate"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "yearSelected": "yearSelected"; }, never, never, true, never>;
+}
+
+/** Injection token for the DateAdapter's locale. */
+declare const MAT_DATE_LOCALE: InjectionToken<string>;
+/** Injection token for the DateAdapter's formats. */
+declare const MAT_DATE_FORMATS: InjectionToken<any>;
+declare abstract class DateAdapter<D> {
+    protected _localeChanges: Subject<void>;
+    readonly localeChanges: Subject<void>;
+    abstract getYear(date: D): number;
+    abstract getMonth(date: D): number;
+    abstract getDate(date: D): number;
+    abstract getDayOfWeek(date: D): number;
+    abstract getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    abstract getDateNames(): string[];
+    abstract getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    abstract getYearName(date: D): string;
+    abstract getFirstDayOfWeek(): number;
+    abstract getNumDaysInMonth(date: D): number;
+    abstract clone(date: D): D;
+    abstract createDate(year: number, month: number, date: number): D;
+    abstract today(): D;
+    abstract parse(value: any, parseFormat: any): D | null;
+    abstract format(date: D, displayFormat: any): string;
+    abstract addCalendarYears(date: D, years: number): D;
+    abstract addCalendarMonths(date: D, months: number): D;
+    abstract addCalendarDays(date: D, days: number): D;
+    abstract toIso8601(date: D): string;
+    abstract isDateInstance(obj: any): obj is D;
+    abstract isValid(date: D): boolean;
+    abstract invalid(): D;
+    setLocale(locale: string): void;
+    protected locale: string;
+    compareDate(first: D, second: D): number;
+    sameDate(first: D | null, second: D | null): boolean;
+    clampDate(date: D, min?: D | null, max?: D | null): D;
+}
+
+declare class NativeDateAdapter extends DateAdapter<Date> {
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getDayOfWeek(date: Date): number;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getYearName(date: Date): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: Date): number;
+    clone(date: Date): Date;
+    createDate(year: number, month: number, date: number): Date;
+    today(): Date;
+    parse(value: any): Date | null;
+    format(date: Date, displayFormat: Object): string;
+    addCalendarYears(date: Date, years: number): Date;
+    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarDays(date: Date, days: number): Date;
+    toIso8601(date: Date): string;
+    isDateInstance(obj: any): obj is Date;
+    isValid(date: Date): boolean;
+    invalid(): Date;
+    private _2digit;
+    private _stripDirectionMarkers;
+    private _createDateWithOverflow;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeDateAdapter, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NativeDateAdapter>;
+}
+
+declare const MAT_NATIVE_DATE_FORMATS: {
+    parse: {
+        dateInput: null;
+    };
+    display: {
+        dateInput: {
+            month: string;
+            year: string;
+            day: string;
+        };
+        monthYearLabel: {
+            month: string;
+            year: string;
+        };
+        dateA11yLabel: {
+            month: string;
+            year: string;
+            day: string;
+        };
+        monthYearA11yLabel: {
+            month: string;
+            year: string;
+        };
+    };
+};
+declare function provideNativeDateAdapter(): Provider[];
+
+declare class DatepickerIntl {
+    readonly changes: Subject<void>;
+    calendarLabel: string;
+    openCalendarLabel: string;
+    prevMonthLabel: string;
+    nextMonthLabel: string;
+    prevYearLabel: string;
+    nextYearLabel: string;
+    prevMultiYearLabel: string;
+    nextMultiYearLabel: string;
+    switchToMonthViewLabel: string;
+    switchToMultiYearViewLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerIntl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DatepickerIntl>;
+}
+
+export { Calendar, DateAdapter, DateRange, DateRangeInput, DateRangePicker, Datepicker, DatepickerActions, DatepickerApply, DatepickerCancel, DatepickerInput, DatepickerIntl, DatepickerToggle, DatepickerToggleIcon, EndDate, MAT_DATE_FORMATS, MAT_DATE_LOCALE, MAT_NATIVE_DATE_FORMATS, MonthView, MultiYearView, NativeDateAdapter, StartDate, YearView, provideNativeDateAdapter };
+export type { DatepickerPreset };

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

@@ -0,0 +1,115 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, EventEmitter, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { CdkDialogContainer } from '@angular/cdk/dialog';
+import { ComponentType } from '@angular/cdk/portal';
+
+declare class DialogConfig<D = any> {
+    data?: D | null;
+    width?: string;
+    height?: string;
+    minWidth?: string | number;
+    minHeight?: string | number;
+    maxWidth?: string | number;
+    maxHeight?: string | number;
+    hasBackdrop?: boolean;
+    backdropClass?: string | string[];
+    panelClass?: string | string[];
+    disableClose?: boolean;
+    autoFocus?: boolean | string;
+    restoreFocus?: boolean;
+    ariaDescribedBy?: string | null;
+    ariaLabelledBy?: string | null;
+    ariaLabel?: string | null;
+    role?: 'dialog' | 'alertdialog';
+    closeOnNavigation?: boolean;
+}
+declare const DIALOG_DATA: InjectionToken<any>;
+declare const DIALOG_DEFAULT_OPTIONS: InjectionToken<DialogConfig<any>>;
+
+declare class DialogContainer extends CdkDialogContainer implements OnInit {
+    private readonly _cdr;
+    readonly _portalOutlet: any;
+    /** State of the dialog animation. */
+    _animationState: 'void' | 'enter' | 'exit';
+    /** Emits when an animation state changes. */
+    _animationStateChanged: EventEmitter<any>;
+    ngOnInit(): void;
+    private _formatValue;
+    _onTransitionEnd(event: TransitionEvent): void;
+    /** Starts the dialog enter animation. */
+    _startEnterAnimation(): void;
+    /** Starts the dialog exit animation. */
+    _startExitAnimation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogContainer, "ngs-dialog-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogRef<T, R = any> {
+    private readonly _afterClosed;
+    private readonly _afterOpened;
+    private readonly _backdropClick;
+    private readonly _keydownEvents;
+    componentInstance: T | null;
+    disableClose: boolean | undefined;
+    /** @internal */
+    _cdkRef: any;
+    /** @internal */
+    _container: DialogContainer | undefined;
+    private _isClosing;
+    close(dialogResult?: R): void;
+    private _finishClose;
+    afterClosed(): Observable<R | undefined>;
+    afterOpened(): Observable<void>;
+    backdropClick(): Observable<MouseEvent>;
+    keydownEvents(): Observable<KeyboardEvent>;
+    __fireAfterOpened(): void;
+    __fireBackdropClick(event: MouseEvent): void;
+    __fireKeydownEvent(event: KeyboardEvent): void;
+}
+
+declare class Dialog {
+    private readonly _cdkDialog;
+    private readonly _injector;
+    private readonly _defaultOptions;
+    open<T, D = any, R = any>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>, config?: DialogConfig<D>): DialogRef<T, R>;
+    close<T, R>(dialogRef: DialogRef<T, R>, result?: R): void;
+    closeAll(): void;
+    private _buildPanelClass;
+    private _buildBackdropClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Dialog, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Dialog>;
+}
+
+declare class DialogTitle implements OnInit {
+    private _dialogRef;
+    id: i0.InputSignal<string>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogTitle, "ngs-dialog-title, [ngs-dialog-title], [ngsDialogTitle]", ["ngsDialogTitle"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DialogContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogContent, "ngs-dialog-content,[ngs-dialog-content],[ngsDialogContent]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class DialogActions {
+    align: i0.InputSignal<"start" | "center" | "end">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogActions, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogActions, "ngs-dialog-actions, [ngs-dialog-actions], [ngsDialogActions]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DialogClose {
+    dialogResult: i0.InputSignal<any>;
+    _dialogResult: i0.InputSignal<any>;
+    ariaLabel: i0.InputSignal<string | null>;
+    type: i0.InputSignal<"submit" | "button" | "reset">;
+    private _dialogRef;
+    private _dialog;
+    protected _onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogClose, "[ngs-dialog-close], [ngsDialogClose]", ["ngsDialogClose"], { "dialogResult": { "alias": "ngs-dialog-close"; "required": false; "isSignal": true; }; "_dialogResult": { "alias": "ngsDialogClose"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DIALOG_DATA, DIALOG_DEFAULT_OPTIONS, Dialog, DialogActions, DialogClose, DialogConfig, DialogContainer, DialogContent, DialogRef, DialogTitle };

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

@@ -0,0 +1,18 @@
+import * as i0 from '@angular/core';
+
+declare class TextDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextDivider, "ngs-text-divider", ["ngsTextDivider"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class Divider {
+    /** Whether the divider is vertically aligned. */
+    vertical: i0.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the divider is an inset divider. */
+    inset: i0.InputSignalWithTransform<boolean, unknown>;
+    fixedHeight: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Divider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Divider, "ngs-divider", ["ngsDivider"], { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "fixedHeight": { "alias": "fixedHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Divider, TextDivider };

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

@@ -0,0 +1,32 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, Signal, TemplateRef, InjectionToken } from '@angular/core';
+
+declare class Drawer implements OnDestroy {
+    private overlay;
+    private viewContainerRef;
+    private destroyRef;
+    readonly initialIsOpen: _angular_core.InputSignal<boolean | undefined>;
+    readonly showBackdrop: _angular_core.InputSignal<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    private internalIsOpen;
+    private overlayRef;
+    protected portal: Signal<TemplateRef<any>>;
+    protected _isOpen: Signal<boolean>;
+    constructor();
+    ngOnDestroy(): void;
+    open(): void;
+    close(): void;
+    get isOpened(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Drawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Drawer, "ngs-drawer", ["ngsDrawer"], { "initialIsOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "showBackdrop": { "alias": "showBackdrop"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "opened": "opened"; }, never, ["*"], true, never>;
+}
+
+declare class DrawerIgnoreOutsideClickDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DrawerIgnoreOutsideClickDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DrawerIgnoreOutsideClickDirective, "[ngsDrawerIgnoreOutsideClick]", never, {}, {}, never, never, true, never>;
+}
+
+declare const DRAWER: InjectionToken<unknown>;
+
+export { DRAWER, Drawer, DrawerIgnoreOutsideClickDirective };

package/types/ngstarter-ui-components-emoji-picker.d.ts

@@ -0,0 +1,49 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, TemplateRef } from '@angular/core';
+import * as _ngstarter_ui_components_overlay from '@ngstarter-ui/components/overlay';
+
+declare class EmojiPicker implements OnInit {
+    private _trigger;
+    private _localeId;
+    language: _angular_core.InputSignal<string>;
+    selectEmojiLabel: _angular_core.InputSignal<string>;
+    readonly emojiSelected: _angular_core.OutputEmitterRef<string>;
+    protected loaded: _angular_core.WritableSignal<boolean>;
+    protected groups: _angular_core.WritableSignal<any[]>;
+    protected _hoveredEmoji: _angular_core.WritableSignal<any>;
+    protected _skeletonEmoji: _angular_core.WritableSignal<any[]>;
+    ngOnInit(): Promise<void>;
+    select(emoji: any): void;
+    hoverEmoji(emoji: any): void;
+    onMouseLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmojiPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmojiPicker, "ngs-emoji-picker", ["ngsEmojiPicker"], { "language": { "alias": "language"; "required": false; "isSignal": true; }; "selectEmojiLabel": { "alias": "selectEmojiLabel"; "required": false; "isSignal": true; }; }, { "emojiSelected": "emojiSelected"; }, never, never, true, never>;
+}
+
+declare class EmojiPickerTriggerForDirective {
+    private _overlay;
+    private _elementRef;
+    private _directionality;
+    private _viewContainerRef;
+    private _injector;
+    private _overlayRef;
+    private _destroyRef;
+    for: _angular_core.InputSignal<TemplateRef<any>>;
+    position: _angular_core.InputSignal<_ngstarter_ui_components_overlay.OverlayPosition>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    get api(): {
+        close: () => void;
+    };
+    protected _onClick(event: Event): void;
+    private _close;
+    private _subscribeToOutsideClicks;
+    private _getPopoverContentPortal;
+    private _getOverlayConfig;
+    private _getOverlayPositionStrategy;
+    private _getOverlayPositions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmojiPickerTriggerForDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EmojiPickerTriggerForDirective, "[ngsEmojiPickerTriggerFor]", ["ngsEmojiPickerTriggerFor"], { "for": { "alias": "ngsEmojiPickerTriggerFor"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+export { EmojiPicker, EmojiPickerTriggerForDirective };

package/types/ngstarter-ui-components-empty-state.d.ts

@@ -0,0 +1,33 @@
+import * as i0 from '@angular/core';
+
+declare class EmptyState {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyState, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyState, "ngs-empty-state", ["ngsEmptyState"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class EmptyStateImage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateImage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateImage, "ngs-empty-state-image", ["ngsEmptyStateImage"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class EmptyStateIcon {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateIcon, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateIcon, "ngs-empty-state-icon", ["ngsEmptyStateIcon"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class EmptyStateTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateTitle, "ngs-empty-state-title,[ngs-empty-state-title]", ["ngsEmptyStateTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class EmptyStateContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateContent, "ngs-empty-state-content", ["ngsEmptyStateContent"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class EmptyStateActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateActions, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateActions, "ngs-empty-state-actions", ["ngsEmptyStateActions"], {}, {}, never, ["*"], true, never>;
+}
+
+export { EmptyState, EmptyStateActions, EmptyStateContent, EmptyStateIcon, EmptyStateImage, EmptyStateTitle };

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

@@ -0,0 +1,26 @@
+import * as _angular_core from '@angular/core';
+
+declare class Expand {
+    private _elementRef;
+    expanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    color: _angular_core.InputSignal<string>;
+    expandLabel: _angular_core.InputSignal<string>;
+    collapseLabel: _angular_core.InputSignal<string>;
+    showButtonIfExpanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    height: _angular_core.InputSignal<string>;
+    readonly expandedChange: _angular_core.OutputEmitterRef<boolean>;
+    protected _expanded: boolean;
+    constructor();
+    get api(): {
+        expand: () => void;
+        collapse: () => void;
+        toggle: () => void;
+    };
+    private _toggle;
+    private _expand;
+    private _collapse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Expand, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Expand, "ngs-expand", ["ngsExpand"], { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "expandLabel": { "alias": "expandLabel"; "required": false; "isSignal": true; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; "isSignal": true; }; "showButtonIfExpanded": { "alias": "showButtonIfExpanded"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "expandedChange": "expandedChange"; }, never, ["*"], true, never>;
+}
+
+export { Expand };