@ngbase/adk 0.1.0

package/checkbox/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/checkbox" />
+export * from './public-api';

package/checkbox/public-api.d.ts

@@ -0,0 +1 @@
+export { CheckboxButton, NgbCheckbox } from './checkbox';

package/chip/chip-group.d.ts

@@ -0,0 +1,7 @@
+import { NgbChip } from './chip';
+import * as i0 from "@angular/core";
+export declare class NgbChipGroup<T> {
+    readonly chips: import("@angular/core").Signal<readonly NgbChip<T>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbChipGroup<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbChipGroup<any>, "[ngbChipGroup]", never, {}, {}, ["chips"], never, true, never>;
+}

package/chip/chip.d.ts

@@ -0,0 +1,19 @@
+import { Directionality } from '@ngbase/adk/bidi';
+import * as i0 from "@angular/core";
+export declare class NgbChipRemove {
+    readonly chip: NgbChip<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbChipRemove, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbChipRemove, "[ngbChipRemove]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbChip<T = any> {
+    readonly dir: Directionality;
+    readonly removable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly value: import("@angular/core").InputSignal<T | undefined>;
+    readonly close: import("@angular/core").OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbChip<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbChip<any>, "[ngbChip]", never, { "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
+}
+export declare const provideChip: (chip: typeof NgbChip) => {
+    provide: typeof NgbChip;
+    useExisting: typeof NgbChip;
+}[];

package/chip/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/chip" />
+export * from './public-api';

package/chip/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './chip';
+export * from './chip-group';

package/clipboard/clipboard.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class CopyToClipboard {
+    readonly ngbCopyToClipboard: import("@angular/core").InputSignal<string | undefined>;
+    onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyToClipboard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopyToClipboard, "[ngbCopyToClipboard]", never, { "ngbCopyToClipboard": { "alias": "ngbCopyToClipboard"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/clipboard/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/clipboard" />
+export * from './public-api';

package/clipboard/public-api.d.ts

@@ -0,0 +1 @@
+export * from './clipboard';

package/collections/SelectionModel.d.ts

@@ -0,0 +1,14 @@
+export declare class SelectionModel<T> {
+    multiple: boolean;
+    readonly selected: import("@angular/core").WritableSignal<T[]>;
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    readonly isEmpty: import("@angular/core").Signal<boolean>;
+    constructor(multiple?: boolean, selected?: T[]);
+    clear(): void;
+    select(item: T): void;
+    deselect(item: T): void;
+    selectAll(items: T[]): void;
+    isSelected(item: T): boolean;
+    toggle(item: T): void;
+    sort(fn: (a: T, b: T) => number): void;
+}

package/collections/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/collections" />
+export * from './public-api';

package/collections/public-api.d.ts

@@ -0,0 +1 @@
+export * from './SelectionModel';

package/color-picker/color-input.d.ts

@@ -0,0 +1,16 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { ColorFormat } from './color-picker';
+import * as i0 from "@angular/core";
+export declare class NgbColorInput implements ControlValueAccessor {
+    readonly format: import("@angular/core").InputSignal<ColorFormat>;
+    readonly presetColors: import("@angular/core").InputSignal<string[] | undefined>;
+    readonly value: import("@angular/core").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>;
+}

package/color-picker/color-picker-trigger.d.ts

@@ -0,0 +1,30 @@
+import { EffectRef, InjectionToken } from '@angular/core';
+import { NgbColorInput } from './color-input';
+import { ColorFormat, NgbColorPicker } from './color-picker';
+import * as i0 from "@angular/core";
+interface ColorPickerOptions {
+    picker: typeof NgbColorPicker;
+    accessor: typeof NgbColorInput;
+}
+export declare const registerColorPicker: ({ picker, accessor }: ColorPickerOptions) => ({
+    provide: import("@angular/core").InjectionToken<readonly import("@angular/forms").ControlValueAccessor[]>;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+} | {
+    provide: InjectionToken<typeof NgbColorPicker>;
+    useValue: typeof NgbColorPicker;
+})[];
+export declare class ColorPickerTrigger {
+    private el;
+    private colorPicker;
+    private popover;
+    private injector;
+    readonly format: import("@angular/core").InputSignal<ColorFormat>;
+    readonly presetColors: import("@angular/core").InputSignal<string[] | undefined>;
+    readonly value: import("@angular/core").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 {};

package/color-picker/color-picker.d.ts

@@ -0,0 +1,72 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/drag";
+export type ColorFormat = 'hex' | 'rgb' | 'hsl' | 'hsb';
+export 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: {}; }]>;
+}
+export declare class ColorSpectrumSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSpectrumSelector, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorSpectrumSelector, "[ngbColorSpectrumSelector]", never, {}, {}, never, never, true, never>;
+}
+export declare class ColorSelected {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSelected, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorSelected, "[ngbColorSelected]", never, {}, {}, never, never, true, never>;
+}
+export 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: {}; }]>;
+}
+export declare class ColorHueThumb {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorHueThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorHueThumb, "[ngbColorHueThumb]", never, {}, {}, never, never, true, never>;
+}
+export declare class ColorAlpha {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorAlpha, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorAlpha, "[ngbColorAlpha]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+export declare class ColorAlphaThumb {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorAlphaThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorAlphaThumb, "[ngbColorAlphaThumb]", never, {}, {}, never, never, true, never>;
+}
+export 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: import("@angular/core").OutputEmitterRef<string>;
+    readonly format: import("@angular/core").InputSignal<ColorFormat>;
+    readonly presetColors: import("@angular/core").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>;
+}

package/color-picker/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/color-picker" />
+export * from './public-api';

package/color-picker/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './color-picker';
+export * from './color-picker-trigger';
+export * from './color-input';

package/color-picker/utils.d.ts

@@ -0,0 +1,21 @@
+export declare function hexToRgb(hex: string): [number, number, number, number];
+export declare function rgbaToHsb(r: number, g: number, b: number, a?: number): {
+    h: number;
+    s: number;
+    b: number;
+    a: number;
+};
+export declare function hexToHsb(hex: string): [number, number, number, number];
+export declare function rgbToHsl(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function parseRgba(rgba: string): [number, number, number, number];
+export declare function parseHsba(hsb: string): [number, number, number, number];
+export declare function hsbToHsl(h: number, s: number, b: number): [number, number, number];
+export declare function hslaToHsba(h: number, s: number, l: number, a?: number): [number, number, number, number];
+export declare function hsbaToRgba(h: number, s: number, b: number, a?: number): [number, number, number, number];
+export declare function rgbToHsba(r: number, g: number, b: number, a?: number): [number, number, number, number];
+export declare function hsbaToHex(h: number, s: number, b: number, a?: number): string;
+export declare function rgbToHex(r: number, g: number, b: number, a?: number): string;

package/cookies/cookie.service.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from "@angular/core";
+export 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>;
+}
+export declare const injectCookie: () => CookieService;

package/cookies/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/cookies" />
+export * from './public-api';

package/cookies/public-api.d.ts

@@ -0,0 +1 @@
+export { CookieService, injectCookie } from './cookie.service';

package/datepicker/calendar.d.ts

@@ -0,0 +1,121 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import { AccessibleItem } from '@ngbase/adk/a11y';
+import { Directionality } from '@ngbase/adk/bidi';
+import { NgbDatePicker } from './datepicker';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/a11y";
+export declare class CalendarBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ngbCalendarBtn: import("@angular/core").InputSignal<"left" | "right">;
+    readonly disabled: import("@angular/core").Signal<boolean>;
+    readonly visible: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarBtn<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarBtn<any>, "[ngbCalendarBtn]", never, { "ngbCalendarBtn": { "alias": "ngbCalendarBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class CalendarTitle<D> {
+    readonly cal: NgbCalendar<D>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarTitle<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarTitle<any>, "[ngbCalendarTitle]", never, {}, {}, never, never, true, never>;
+}
+export declare class CalendarYearBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ally: AccessibleItem<any>;
+    readonly ngbCalYearBtn: import("@angular/core").InputSignal<{
+        year: number;
+        disabled: boolean;
+    }>;
+    readonly active: import("@angular/core").Signal<boolean>;
+    readonly selected: import("@angular/core").Signal<boolean | 0>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarYearBtn<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarYearBtn<any>, "[ngbCalYearBtn]", ["ngbCalYearBtn"], { "ngbCalYearBtn": { "alias": "ngbCalYearBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+export declare class CalendarMonthBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ally: AccessibleItem<any>;
+    readonly ngbCalMonthBtn: import("@angular/core").InputSignal<{
+        name: string;
+        value: number;
+        disabled: boolean;
+    }>;
+    readonly active: import("@angular/core").Signal<boolean>;
+    readonly selected: import("@angular/core").Signal<boolean | 0>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarMonthBtn<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarMonthBtn<any>, "[ngbCalMonthBtn]", ["ngbCalMonthBtn"], { "ngbCalMonthBtn": { "alias": "ngbCalMonthBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+export declare class CalendarDayBtn<D> {
+    readonly cal: NgbCalendar<D>;
+    readonly ally: AccessibleItem<any>;
+    readonly ngbCalDayBtn: import("@angular/core").InputSignal<{
+        day: number;
+        mon: number;
+        disabled: boolean;
+        current: boolean;
+        count: number;
+    }>;
+    readonly active: import("@angular/core").Signal<boolean>;
+    readonly dummy: import("@angular/core").Signal<boolean>;
+    readonly selected: import("@angular/core").Signal<boolean | 0>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarDayBtn<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarDayBtn<any>, "[ngbCalDayBtn]", ["ngbCalDayBtn"], { "ngbCalDayBtn": { "alias": "ngbCalDayBtn"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+export declare class NgbCalendar<D> implements OnDestroy {
+    readonly dir: Directionality;
+    readonly datePicker: NgbDatePicker<D>;
+    readonly days: import("@angular/core").Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly first: import("@angular/core").InputSignal<boolean>;
+    readonly last: import("@angular/core").InputSignal<boolean>;
+    readonly index: import("@angular/core").InputSignal<number>;
+    readonly time1: import("@angular/core").WritableSignal<string | null>;
+    readonly time2: import("@angular/core").WritableSignal<string | null>;
+    readonly cStartMonth: import("@angular/core").Signal<number>;
+    readonly cStartYear: import("@angular/core").Signal<number>;
+    readonly selectedMonthName: import("@angular/core").Signal<string>;
+    readonly currentYear: import("@angular/core").WritableSignal<number>;
+    readonly years: import("@angular/core").Signal<{
+        year: number;
+        disabled: boolean;
+    }[]>;
+    readonly months: import("@angular/core").Signal<{
+        name: string;
+        value: number;
+        disabled: boolean;
+    }[]>;
+    readonly title: import("@angular/core").Signal<string | number>;
+    readonly dayNames: string[];
+    getDaysArray: import("@angular/core").Signal<{
+        mon: number;
+        day: number;
+        year: number;
+        disabled: boolean;
+        current: boolean;
+        count: number;
+    }[]>;
+    leftBtn: import("@angular/core").Signal<boolean>;
+    rightBtn: import("@angular/core").Signal<boolean>;
+    todayDay: import("@angular/core").Signal<number>;
+    eventListeners: {
+        element: HTMLElement;
+        listener: () => void;
+    }[];
+    constructor();
+    get adapter(): import("@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: i0.ɵɵFactoryDeclaration<NgbCalendar<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<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>;
+}
+export declare function provideCalendar<D>(cal: typeof NgbCalendar): {
+    provide: typeof NgbCalendar;
+    useExisting: typeof NgbCalendar;
+};

package/datepicker/datepicker-trigger.d.ts

@@ -0,0 +1,49 @@
+import { ElementRef, InjectionToken, TemplateRef } from '@angular/core';
+import { InputBase } from '@ngbase/adk/form-field';
+import { NgbDatePicker } from './datepicker';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/form-field";
+export declare class NgbDatepickerTrigger<D> {
+    readonly el: ElementRef<any>;
+    readonly inputS: InputBase<any>;
+    private readonly injector;
+    readonly adapter: import("@ngbase/adk/datepicker").NgbAdpterInterface<D>;
+    readonly popover: {
+        open: <T>(component: import("@ngbase/adk/portal").DialogInput<T>, options: import("@ngbase/adk/popover").PopoverOptions) => import("@ngbase/adk/popover").PopoverOpen<T>;
+        closeAll: () => void;
+    };
+    private datepicker;
+    readonly noOfCalendars: import("@angular/core").InputSignalWithTransform<number, number>;
+    readonly range: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly time: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly format: import("@angular/core").InputSignal<string>;
+    readonly fieldFormat: import("@angular/core").InputSignal<string>;
+    private displayFormat;
+    readonly dateFilter: import("@angular/core").InputSignal<(date: D) => boolean>;
+    readonly pickerType: import("@angular/core").InputSignal<"year" | "month" | "date">;
+    readonly pickerTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+    close?: VoidFunction;
+    constructor();
+    private getInputValue;
+    open(): void;
+    updateInput(dates: (D | null)[]): void;
+    updateField(filtered: D[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatepickerTrigger<any>, never>;
+    static ɵdir: i0.ɵɵ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: {}; outputs: {}; }]>;
+}
+export interface DatePickerOptions<D> {
+    value: 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;
+}
+export declare function registerDatePicker<D>(datePicker: typeof NgbDatePicker<D>): {
+    provide: InjectionToken<typeof NgbDatePicker>;
+    useValue: typeof NgbDatePicker<D>;
+};

package/datepicker/datepicker.d.ts

@@ -0,0 +1,54 @@
+import { TemplateRef } from '@angular/core';
+import { AccessibleGroup } from '@ngbase/adk/a11y';
+import { DatePickerOptions } from './datepicker-trigger';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/a11y";
+export declare class DatepickerGroup<D> {
+    readonly picker: NgbDatePicker<D>;
+    readonly allyGroup: AccessibleGroup;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerGroup<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatepickerGroup<any>, "[ngbDatepickerGroup]", ["ngbDatepickerGroup"], {}, {}, never, never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+export declare class NgbDatePicker<D> {
+    private datepickerTrigger;
+    private dialogRef;
+    readonly adapter: import("@ngbase/adk/datepicker").NgbAdpterInterface<D>;
+    readonly dateFilter: import("@angular/core").InputSignal<(date: D) => boolean>;
+    readonly pickerType: import("@angular/core").InputSignal<"year" | "month" | "date">;
+    readonly allyGroup: import("@angular/core").Signal<AccessibleGroup | undefined>;
+    readonly noOfCalendar: import("@angular/core").ModelSignal<number>;
+    readonly range: import("@angular/core").ModelSignal<boolean>;
+    readonly time: import("@angular/core").WritableSignal<boolean>;
+    readonly format: import("@angular/core").WritableSignal<string>;
+    readonly template: import("@angular/core").WritableSignal<TemplateRef<any> | null>;
+    readonly showType: import("@angular/core").WritableSignal<"year" | "month" | "date">;
+    readonly selectedDates: import("@angular/core").WritableSignal<[D | null, D | null]>;
+    readonly times: import("@angular/core").WritableSignal<[string | null, string | null]>;
+    readonly startDate: import("@angular/core").Signal<D>;
+    readonly startMonth: import("@angular/core").WritableSignal<number>;
+    readonly startYear: import("@angular/core").WritableSignal<number>;
+    readonly hoveredDate: import("@angular/core").WritableSignal<D | null>;
+    readonly hoveredCount: import("@angular/core").Signal<number>;
+    readonly startDateCount: import("@angular/core").Signal<number>;
+    readonly dates: import("@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: i0.ɵɵFactoryDeclaration<NgbDatePicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<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>;
+}
+export declare function provideDatePicker<D>(picker: typeof NgbDatePicker<D>): {
+    provide: typeof NgbDatePicker;
+    useExisting: typeof NgbDatePicker<D>;
+};

package/datepicker/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/datepicker" />
+export * from './public-api';

package/datepicker/native-date-adapter.d.ts

@@ -0,0 +1,33 @@
+import { InjectionToken } from '@angular/core';
+export type NgbDateUnits = 'year' | 'month' | 'date' | 'hour' | 'minute' | 'second' | 'millisecond';
+export 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;
+}
+export declare const NgbDateAdapter: InjectionToken<NgbAdpterInterface<unknown>>;
+export declare function injectNgbDateAdapter<D>(): NgbAdpterInterface<D>;
+export 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;
+}

package/datepicker/public-api.d.ts

@@ -0,0 +1,5 @@
+export * from './calendar';
+export * from './datepicker';
+export * from './datepicker-trigger';
+export * from './time';
+export * from './native-date-adapter';

package/datepicker/time.d.ts

@@ -0,0 +1,42 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { NumberOnly } from '@ngbase/adk/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/utils";
+export declare class NgbTimeInput {
+    readonly numberOnly: NumberOnly;
+    readonly timePicker: NgbTimePicker;
+    readonly ngbTimeInput: import("@angular/core").InputSignal<"hours" | "minutes" | "seconds">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTimeInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTimeInput, "[ngbTimeInput]", never, { "ngbTimeInput": { "alias": "ngbTimeInput"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NumberOnly; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+export declare class NgbTimePicker implements ControlValueAccessor {
+    readonly is24: import("@angular/core").InputSignal<boolean>;
+    readonly value: import("@angular/core").InputSignal<string | null | undefined>;
+    readonly valueChange: import("@angular/core").OutputEmitterRef<string | null | undefined>;
+    private time;
+    readonly hours: import("@angular/core").WritableSignal<string>;
+    readonly minutes: import("@angular/core").WritableSignal<string>;
+    readonly seconds: import("@angular/core").WritableSignal<string>;
+    readonly am: import("@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: i0.ɵɵFactoryDeclaration<NgbTimePicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTimePicker, "[ngbTime]", never, { "is24": { "alias": "is24"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+export declare function provideTimePicker(picker: typeof NgbTimePicker): ({
+    provide: import("@angular/core").InjectionToken<readonly import("@angular/forms").ControlValueAccessor[]>;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+}[] | {
+    provide: typeof NgbTimePicker;
+    useExisting: typeof NgbTimePicker;
+})[];

package/dialog/dialog.animation.d.ts

@@ -0,0 +1,3 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+export declare const sideAnimation: AnimationTriggerMetadata;
+export declare const viewAnimation: AnimationTriggerMetadata;