@ngbase/adk 0.1.11 → 0.1.12

package/color-picker/index.d.ts

@@ -1,5 +1,119 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/color-picker" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InjectionToken, EffectRef } from '@angular/core';
+import * as i1 from '@ngbase/adk/drag';
+import * as _angular_forms from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+
+type ColorFormat = 'hex' | 'rgb' | 'hsl' | 'hsb';
+declare class ColorSpectrum {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSpectrum, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorSpectrum, "[ngbColorSpectrum]", never, {}, {}, never, never, true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+declare class ColorSpectrumSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSpectrumSelector, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorSpectrumSelector, "[ngbColorSpectrumSelector]", never, {}, {}, never, never, true, never>;
+}
+declare class ColorSelected {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSelected, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorSelected, "[ngbColorSelected]", never, {}, {}, never, never, true, never>;
+}
+declare class ColorHue {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorHue, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorHue, "[ngbColorHue]", never, {}, {}, never, never, true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+declare class ColorHueThumb {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorHueThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorHueThumb, "[ngbColorHueThumb]", never, {}, {}, never, never, true, never>;
+}
+declare class ColorAlpha {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorAlpha, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorAlpha, "[ngbColorAlpha]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+declare class ColorAlphaThumb {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorAlphaThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorAlphaThumb, "[ngbColorAlphaThumb]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbColorPicker {
+    private readonly el;
+    private readonly dialogRef;
+    private readonly hueDiv;
+    private readonly hueSelector;
+    private readonly spectrumDiv;
+    private readonly spectrumSelector;
+    private readonly selectedColor;
+    private alpha;
+    private readonly alphaDiv;
+    private readonly alphaSelector;
+    readonly valueChange: i0.OutputEmitterRef<string>;
+    readonly format: i0.InputSignal<ColorFormat>;
+    readonly presetColors: i0.InputSignal<string[]>;
+    private hue;
+    private saturation;
+    private brightness;
+    private lastSpectrumEvent?;
+    private localValue;
+    private colorParsers;
+    constructor();
+    private calculateCoordinates;
+    private setupEventListeners;
+    private setupDragListener;
+    private handleColorEvent;
+    private updateHue;
+    private updateSpectrum;
+    private updateAlpha;
+    setValue(value: string, emit?: boolean): void;
+    private updateSelectorPositions;
+    private updateSelectorPosition;
+    private updateSpectrumSelectorPosition;
+    private calculateSpectrumPosition;
+    private calculateSaturationAndLuminous;
+    private updateValue;
+    private getColor;
+    private parse;
+    private toString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbColorPicker, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbColorPicker, "ngb-color-picker-container", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class NgbColorInput implements ControlValueAccessor {
+    readonly format: i0.InputSignal<ColorFormat>;
+    readonly presetColors: i0.InputSignal<string[] | undefined>;
+    readonly value: i0.ModelSignal<string>;
+    onChange: (_: string) => void;
+    onTouched: () => void;
+    updateValue(value?: string): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbColorInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbColorInput, "[ngbColorInput]", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+interface ColorPickerOptions {
+    picker: typeof NgbColorPicker;
+    accessor: typeof NgbColorInput;
+}
+declare const registerColorPicker: ({ picker, accessor }: ColorPickerOptions) => ({
+    provide: InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+} | {
+    provide: InjectionToken<typeof NgbColorPicker>;
+    useValue: typeof NgbColorPicker;
+})[];
+declare class ColorPickerTrigger {
+    private el;
+    private colorPicker;
+    private popover;
+    private injector;
+    readonly format: i0.InputSignal<ColorFormat>;
+    readonly presetColors: i0.InputSignal<string[] | undefined>;
+    readonly value: i0.ModelSignal<string | undefined>;
+    effectRef?: EffectRef;
+    open(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPickerTrigger, "[ngbColorPickerTrigger]", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+export { ColorAlpha, ColorAlphaThumb, ColorHue, ColorHueThumb, ColorPickerTrigger, ColorSelected, ColorSpectrum, ColorSpectrumSelector, NgbColorInput, NgbColorPicker, registerColorPicker };
+export type { ColorFormat };

package/cookies/index.d.ts

@@ -1,5 +1,35 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/cookies" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+declare class CookieService {
+    private readonly sameSite;
+    constructor();
+    set(name: string, value: string, options?: {
+        expires?: number | Date;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        sameSite?: 'Lax' | 'Strict' | 'None';
+    }): void;
+    get(name: string): string | null;
+    delete(name: string, options?: {
+        path?: string;
+        domain?: string;
+    }): void;
+    getAll(): {
+        [key: string]: string;
+    };
+    clearAll(): void;
+    has(name: string): boolean;
+    update(name: string, newValue: string, options?: {
+        expires?: number | Date;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        sameSite?: 'Lax' | 'Strict' | 'None';
+    }): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookieService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CookieService>;
+}
+declare const injectCookie: () => CookieService;
+
+export { CookieService, injectCookie };

package/datepicker/index.d.ts

@@ -1,5 +1,317 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/datepicker" />
-export * from './public-api';
+import * as _ngbase_adk_datepicker from '@ngbase/adk/datepicker';
+import * as _angular_core from '@angular/core';
+import { ElementRef, TemplateRef, Signal, InjectionToken, Injector, OnDestroy } from '@angular/core';
+import * as i1$1 from '@ngbase/adk/a11y';
+import { AccessibleGroup, AccessibleItem } from '@ngbase/adk/a11y';
+import { Directionality } from '@ngbase/adk/bidi';
+import * as _ngbase_adk_popover from '@ngbase/adk/popover';
+import * as _ngbase_adk_portal from '@ngbase/adk/portal';
+import * as i1 from '@ngbase/adk/form-field';
+import { InputBase } from '@ngbase/adk/form-field';
+import { NgbSelectTarget } from '@ngbase/adk/select';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1$2 from '@ngbase/adk/utils';
+import { NumberOnly } from '@ngbase/adk/utils';
+
+declare class NgbEndDate<D> {
+    readonly el: ElementRef<HTMLInputElement>;
+    readonly inputS: InputBase<any>;
+    readonly ngbEndDate: _angular_core.InputSignal<NgbDatepickerTrigger<D>>;
+    hidden: boolean;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbEndDate<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbEndDate<any>, "[ngbEndDate]", ["ngbEndDate"], { "ngbEndDate": { "alias": "ngbEndDate"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.InputBase; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+declare class NgbDatepickerTrigger<D> {
+    readonly el: ElementRef<any>;
+    readonly inputS: InputBase<any>;
+    readonly target: NgbSelectTarget | null;
+    private readonly injector;
+    readonly adapter: _ngbase_adk_datepicker.NgbAdpterInterface<D>;
+    readonly popover: {
+        open: <T>(component: _ngbase_adk_portal.DialogInput<T>, options: _ngbase_adk_popover.PopoverOptions) => _ngbase_adk_popover.PopoverOpen<T>;
+        closeAll: () => void;
+    };
+    private datepicker;
+    readonly noOfCalendars: _angular_core.InputSignalWithTransform<number, string | number>;
+    readonly range: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly time: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly format: _angular_core.InputSignal<string>;
+    readonly fieldFormat: _angular_core.InputSignal<string>;
+    readonly dateFilter: _angular_core.InputSignal<(date: D) => boolean>;
+    readonly pickerType: _angular_core.InputSignal<"year" | "month" | "date">;
+    readonly pickerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    private displayFormat;
+    close?: VoidFunction;
+    private readonly inputValue;
+    endDate?: NgbEndDate<D>;
+    constructor();
+    private getInputValue;
+    open(): void;
+    updateInput(dates: (D | null)[]): void;
+    updateField(filtered: D[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbDatepickerTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbDatepickerTrigger<any>, "[ngbDatepickerTrigger]", ["ngbDatepickerTrigger"], { "noOfCalendars": { "alias": "noOfCalendars"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "time": { "alias": "time"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "fieldFormat": { "alias": "fieldFormat"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "pickerType": { "alias": "pickerType"; "required": false; "isSignal": true; }; "pickerTemplate": { "alias": "pickerTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.InputBase; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+declare function aliasDatePickerTrigger<D>(trigger: typeof NgbDatepickerTrigger<D>): {
+    provide: typeof NgbDatepickerTrigger;
+    useExisting: typeof NgbDatepickerTrigger<D>;
+};
+interface DatePickerOptions<D> {
+    value: Signal<D[]>;
+    pickerType: 'date' | 'month' | 'year';
+    noOfCalendars: number;
+    range: boolean;
+    format: string;
+    fieldFormat: string;
+    target: any;
+    template: TemplateRef<any> | null;
+    dateFilter: (date: D) => boolean;
+    time: boolean;
+}
+declare function registerDatePicker<D>(datePicker: typeof NgbDatePicker<D>): {
+    provide: InjectionToken<typeof NgbDatePicker>;
+    useValue: typeof NgbDatePicker<D>;
+};
+
+declare class DatepickerGroup<D> {
+    readonly picker: NgbDatePicker<D>;
+    readonly allyGroup: AccessibleGroup;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DatepickerGroup<any>, "[ngbDatepickerGroup]", ["ngbDatepickerGroup"], {}, {}, never, never, true, [{ directive: typeof i1$1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+declare class NgbDatePicker<D> {
+    readonly injector: Injector;
+    private datepickerTrigger;
+    private dialogRef;
+    readonly adapter: _ngbase_adk_datepicker.NgbAdpterInterface<D>;
+    readonly allyGroup: _angular_core.Signal<AccessibleGroup | undefined>;
+    readonly dateFilter: _angular_core.InputSignal<(date: D) => boolean>;
+    readonly pickerType: _angular_core.InputSignal<"year" | "month" | "date">;
+    readonly noOfCalendar: _angular_core.ModelSignal<number>;
+    readonly range: _angular_core.ModelSignal<boolean>;
+    readonly time: _angular_core.WritableSignal<boolean>;
+    readonly format: _angular_core.WritableSignal<string>;
+    readonly template: _angular_core.WritableSignal<TemplateRef<any> | null>;
+    readonly showType: _angular_core.WritableSignal<"year" | "month" | "date">;
+    readonly selectedDates: _angular_core.WritableSignal<[D | null, D | null]>;
+    readonly times: _angular_core.WritableSignal<[string | null, string | null]>;
+    readonly startDate: _angular_core.Signal<D>;
+    readonly startMonth: _angular_core.WritableSignal<number>;
+    readonly startYear: _angular_core.WritableSignal<number>;
+    readonly hoveredDate: _angular_core.WritableSignal<D | null>;
+    readonly hoveredCount: _angular_core.Signal<number>;
+    readonly startDateCount: _angular_core.Signal<number>;
+    readonly dates: _angular_core.Signal<{
+        year: number[];
+        month: string[];
+        day: string[];
+    }>;
+    readonly ayId: string;
+    constructor();
+    private init;
+    get data(): DatePickerOptions<D> | undefined;
+    updateHoveredDate(date: D): void;
+    selectDate(date: D, index?: number): void;
+    selectYear(year: number): void;
+    selectMonth(month: number, year: number): void;
+    toggleView(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbDatePicker<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbDatePicker<any>, "[ngbDatepicker]", never, { "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "pickerType": { "alias": "pickerType"; "required": false; "isSignal": true; }; "noOfCalendar": { "alias": "noOfCalendar"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; }, { "noOfCalendar": "noOfCalendarChange"; "range": "rangeChange"; }, never, never, true, never>;
+}
+declare function aliasDatePicker<D>(picker: typeof NgbDatePicker<D>): {
+    provide: typeof NgbDatePicker;
+    useExisting: typeof NgbDatePicker<D>;
+};
+
+declare class CalendarBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ngbCalendarBtn: _angular_core.InputSignal<"left" | "right">;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly visible: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarBtn<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CalendarBtn<any>, "button[ngbCalendarBtn]", never, { "ngbCalendarBtn": { "alias": "ngbCalendarBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class CalendarTitle<D> {
+    readonly cal: NgbCalendar<D>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarTitle<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CalendarTitle<any>, "[ngbCalendarTitle]", never, {}, {}, never, never, true, never>;
+}
+declare class CalendarYearBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ally: AccessibleItem<any>;
+    readonly ngbCalYearBtn: _angular_core.InputSignal<{
+        year: number;
+        disabled: boolean;
+    }>;
+    readonly active: _angular_core.Signal<boolean>;
+    readonly selected: _angular_core.Signal<boolean | 0>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarYearBtn<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CalendarYearBtn<any>, "[ngbCalYearBtn]", ["ngbCalYearBtn"], { "ngbCalYearBtn": { "alias": "ngbCalYearBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+declare class CalendarMonthBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ally: AccessibleItem<any>;
+    readonly ngbCalMonthBtn: _angular_core.InputSignal<{
+        name: string;
+        value: number;
+        disabled: boolean;
+    }>;
+    readonly active: _angular_core.Signal<boolean>;
+    readonly selected: _angular_core.Signal<boolean | 0>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarMonthBtn<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CalendarMonthBtn<any>, "[ngbCalMonthBtn]", ["ngbCalMonthBtn"], { "ngbCalMonthBtn": { "alias": "ngbCalMonthBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+declare class CalendarDayBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ally: AccessibleItem<any>;
+    readonly ngbCalDayBtn: _angular_core.InputSignal<{
+        day: number;
+        mon: number;
+        disabled: boolean;
+        current: boolean;
+        count: number;
+    }>;
+    readonly active: _angular_core.Signal<boolean>;
+    readonly dummy: _angular_core.Signal<boolean>;
+    readonly selected: _angular_core.Signal<boolean | 0>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarDayBtn<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CalendarDayBtn<any>, "[ngbCalDayBtn]", ["ngbCalDayBtn"], { "ngbCalDayBtn": { "alias": "ngbCalDayBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+declare class NgbCalendar<D> implements OnDestroy {
+    readonly dir: Directionality;
+    readonly datePicker: NgbDatePicker<D>;
+    readonly days: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly first: _angular_core.InputSignal<boolean>;
+    readonly last: _angular_core.InputSignal<boolean>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly time1: _angular_core.WritableSignal<string | null>;
+    readonly time2: _angular_core.WritableSignal<string | null>;
+    readonly cStartMonth: _angular_core.Signal<number>;
+    readonly cStartYear: _angular_core.Signal<number>;
+    readonly selectedMonthName: _angular_core.Signal<string>;
+    readonly currentYear: _angular_core.WritableSignal<number>;
+    readonly years: _angular_core.Signal<{
+        year: number;
+        disabled: boolean;
+    }[]>;
+    readonly months: _angular_core.Signal<{
+        name: string;
+        value: number;
+        disabled: boolean;
+    }[]>;
+    readonly title: _angular_core.Signal<string | number>;
+    readonly dayNames: string[];
+    getDaysArray: _angular_core.Signal<{
+        mon: number;
+        day: number;
+        year: number;
+        disabled: boolean;
+        current: boolean;
+        count: number;
+    }[]>;
+    leftBtn: _angular_core.Signal<boolean>;
+    rightBtn: _angular_core.Signal<boolean>;
+    todayDay: _angular_core.Signal<number>;
+    eventListeners: {
+        element: HTMLElement;
+        listener: () => void;
+    }[];
+    constructor();
+    get adapter(): _ngbase_adk_datepicker.NgbAdpterInterface<D>;
+    private getSelectedDayOfMonth;
+    clearListeners(): void;
+    hoverDate(day: number, month: number): void;
+    timeChanged(index: number, timing: string): void;
+    selectDate(day: number, month: number): void;
+    navigate(direction: number): void;
+    selectYear(year: number): void;
+    selectMonth(month: any): void;
+    toggleView(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbCalendar<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbCalendar<any>, "ngb-calendar", never, { "first": { "alias": "first"; "required": false; "isSignal": true; }; "last": { "alias": "last"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare function aliasCalendar<D>(cal: typeof NgbCalendar<D>): {
+    provide: typeof NgbCalendar;
+    useExisting: typeof NgbCalendar<D>;
+};
+
+declare class NgbTimeInput {
+    readonly numberOnly: NumberOnly;
+    readonly timePicker: NgbTimePicker;
+    readonly ngbTimeInput: _angular_core.InputSignal<"hours" | "minutes" | "seconds">;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTimeInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTimeInput, "[ngbTimeInput]", never, { "ngbTimeInput": { "alias": "ngbTimeInput"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.NumberOnly; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+declare class NgbTimePicker implements ControlValueAccessor {
+    readonly is24: _angular_core.InputSignal<boolean>;
+    readonly value: _angular_core.InputSignal<string | null | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | null | undefined>;
+    private time;
+    readonly hours: _angular_core.WritableSignal<string>;
+    readonly minutes: _angular_core.WritableSignal<string>;
+    readonly seconds: _angular_core.WritableSignal<string>;
+    readonly am: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    constructor();
+    private parseValue;
+    changeAm(active: boolean): void;
+    updateValue(): void;
+    private notify;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTimePicker, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTimePicker, "[ngbTime]", never, { "is24": { "alias": "is24"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+declare function aliasTimePicker(picker: typeof NgbTimePicker): ({
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+}[] | {
+    provide: typeof NgbTimePicker;
+    useExisting: typeof NgbTimePicker;
+})[];
+
+type NgbDateUnits = 'year' | 'month' | 'date' | 'hour' | 'minute' | 'second' | 'millisecond';
+interface NgbAdpterInterface<D> {
+    now(): D;
+    compare(first: D, second: D): number;
+    getTime(date: D): number;
+    getYear(date: D): number;
+    getMonth(date: D): number;
+    getDate(date: D): number;
+    getDay(date: D): number;
+    create(year: number, month?: number, date?: number): D;
+    format(date: D, displayFormat: any): string;
+    parse(value: D | string, parseFormat?: string): D;
+    set(date: D, value: number, unit: NgbDateUnits): D;
+    longMonthNames(date: D): string;
+}
+declare const NgbDateAdapter: InjectionToken<NgbAdpterInterface<unknown>>;
+declare function injectNgbDateAdapter<D>(): NgbAdpterInterface<D>;
+declare class NgbNativeDateAdapter implements NgbAdpterInterface<Date> {
+    now(): Date;
+    create(year: number, month?: number, date?: number): Date;
+    compare(first: Date, second: Date): number;
+    getTime(date: Date): number;
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getDay(date: Date): number;
+    format(date: Date, format: string): string;
+    private pad;
+    parse(value: Date | string, _?: string): Date;
+    set(date: Date, value: number, unit: NgbDateUnits): Date;
+    longMonthNames(date: Date): string;
+}
+
+export { CalendarBtn, CalendarDayBtn, CalendarMonthBtn, CalendarTitle, CalendarYearBtn, DatepickerGroup, NgbCalendar, NgbDateAdapter, NgbDatePicker, NgbDatepickerTrigger, NgbEndDate, NgbNativeDateAdapter, NgbTimeInput, NgbTimePicker, aliasCalendar, aliasDatePicker, aliasDatePickerTrigger, aliasTimePicker, injectNgbDateAdapter, registerDatePicker };
+export type { DatePickerOptions, NgbAdpterInterface, NgbDateUnits };

package/dialog/index.d.ts

@@ -1,5 +1,63 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/dialog" />
-export * from './public-api';
+import * as i2 from '@ngbase/adk/portal';
+import { DialogOptions, BaseDialog, DialogInput } from '@ngbase/adk/portal';
+import * as i0 from '@angular/core';
+import { ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i1 from '@ngbase/adk/a11y';
+import { AnimationTriggerMetadata } from '@angular/animations';
+
+declare class NgbDialogMain {
+    readonly dialog: NgbDialogContainer;
+    readonly options: i0.WritableSignal<DialogOptions<any>>;
+    readonly classNames: i0.Signal<string>;
+    readonly style: i0.Signal<{
+        width: string | undefined;
+        height: string | undefined;
+        maxWidth: string | undefined;
+        maxHeight: string;
+        minHeight: string | undefined;
+        minWidth: string | undefined;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDialogMain, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDialogMain, "[ngbDialogMain]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbDialogBackdrop {
+    readonly dialog: NgbDialogContainer;
+    readonly options: i0.WritableSignal<DialogOptions<any>>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDialogBackdrop, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDialogBackdrop, "[ngbDialogBackdrop]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbDialogContainer extends BaseDialog {
+    readonly myDialog: i0.Signal<ViewContainerRef | undefined>;
+    backdropColor: boolean;
+    isSidePopup: boolean;
+    readonly onDone: Subject<any>;
+    readonly options: i0.WritableSignal<DialogOptions<any>>;
+    readonly showBackdrop: i0.Signal<boolean | undefined>;
+    isHideHeader: boolean;
+    constructor();
+    setOptions(options: DialogOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDialogContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDialogContainer, "[ngbDialog]", never, {}, {}, never, never, true, [{ directive: typeof i1.FocusTrap; inputs: {}; outputs: {}; }]>;
+}
+declare class NgbDialogClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDialogClose, "[ngbDialogClose]", never, {}, {}, never, never, true, [{ directive: typeof i2.NgbPortalClose; inputs: { "ngbPortalClose": "ngbDialogClose"; }; outputs: {}; }]>;
+}
+declare function aliasDialog(dialog: typeof NgbDialogContainer): {
+    provide: typeof NgbDialogContainer;
+    useExisting: typeof NgbDialogContainer;
+};
+
+declare function ngbDialogPortal(component: typeof NgbDialogContainer): {
+    open: <T>(component: DialogInput, opt?: DialogOptions) => i2.DialogRef<any>;
+    closeAll: () => void;
+};
+type NgbDialog = ReturnType<typeof ngbDialogPortal>;
+
+declare const sideAnimation: AnimationTriggerMetadata;
+declare const viewAnimation: AnimationTriggerMetadata;
+
+export { NgbDialogBackdrop, NgbDialogClose, NgbDialogContainer, NgbDialogMain, aliasDialog, ngbDialogPortal, sideAnimation, viewAnimation };
+export type { NgbDialog };