ngx-kit 1.0.0 → 2.0.1

package/types/ngx-kit-date-picker.d.ts

@@ -0,0 +1,294 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, InjectionToken, Type, EventEmitter, ElementRef, OnInit, AfterViewInit, Provider } from '@angular/core';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as ngx_kit_date_picker from 'ngx-kit/date-picker';
+import { BrowserService } from 'ngx-kit/shared';
+
+declare class NgxDatePickerConfig {
+    previousButtonTemplate?: TemplateRef<any>;
+    nextButtonTemplate?: TemplateRef<any>;
+    caretDownIconTemplate?: TemplateRef<any>;
+    todayButton: boolean;
+    clearButton: boolean;
+    clearButtonText: string;
+    todayButtonText: string;
+}
+
+declare type DatePickerView = 'year' | 'month' | 'day';
+declare type CalendarView = 'month' | 'week' | 'day' | 'event';
+
+interface CalendarDate {
+    locale: string;
+    year: number;
+    month?: number;
+    day?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+    dayOfWeek?: number;
+    date?: Date;
+}
+
+interface IDateAdapter {
+    get longMonths(): string[];
+    get narrowDays(): string[];
+    get shortDays(): string[];
+    get longDays(): string[];
+    startOfWeek: number;
+    /** convert js date to locale */
+    toLocale(date: Date): CalendarDate;
+    /** get today of localy */
+    today(): CalendarDate;
+    /**
+     *  getting first day of month
+     *
+     * شماره  اولین روز از ماه
+     * * مثلا 0 یعنی شنبه
+     */
+    firstDayofMonth(year: number, month: number): number;
+    /**
+     * getting last date of month
+     *
+     * این ماه چند روز است
+     * * آخرین روز ماه جندم می شود؟
+     */
+    lastDateofMonth(year: number, month: number): number;
+    /**
+     * getting last day of month
+     *
+     * شماره  آخرین روز از ماه
+     * * مثلا 0 یعنی شنبه
+     */
+    lastDayofMonth(year: number, month: number): number;
+    /**
+     * getting last date of previous month
+     *
+     * آخرین روز از ماه گذشته
+     * * ماه قبل چند روز بوده است؟
+     */
+    lastDateofLastMonth(year: number, month: number): number;
+    getDate(date: CalendarDate): Date;
+    formatDate(date: CalendarDate, format: string): string | null;
+    getStartOf(date: Date | null, t: DatePickerView): Date | null;
+    getLastOf(date: Date | null, t: DatePickerView): Date | null;
+}
+
+declare const DATE_ADAPTERS: InjectionToken<DateAdapterRegistration[]>;
+interface DateAdapterRegistration {
+    locale: string;
+    useClass: Type<IDateAdapter>;
+}
+declare const DEFAULT_DATE_ADAPTERS: readonly DateAdapterRegistration[];
+declare function getLocals(): string[];
+
+declare class DateAdapterRegistry {
+    adapters: DateAdapterRegistration[];
+    resolve(locale: string): ngx_kit_date_picker.IDateAdapter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateAdapterRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateAdapterRegistry>;
+}
+
+declare class NgxInputDatePicker implements ControlValueAccessor, Validator {
+    private el;
+    protected readonly dateAdapterRegistry: DateAdapterRegistry;
+    theme: 'light' | 'dark' | 'auto';
+    openOnCLick: i0.InputSignal<boolean>;
+    change: EventEmitter<Date>;
+    private value?;
+    private pickerRef?;
+    adapter: IDateAdapter;
+    private _locale;
+    set locale(val: string);
+    protected _onChange: (value: Date | null | undefined) => void;
+    protected _onTouched: () => void;
+    protected _validatorOnChange: () => void;
+    /**
+     * display format in input
+     */
+    displayFormat: string;
+    private min;
+    /** The minimum valid date. */
+    set setMin(value: Date | null | undefined);
+    private max;
+    /** The maximum valid date. */
+    set setMax(value: Date | null | undefined);
+    config: NgxDatePickerConfig;
+    set setConfig(val: NgxDatePickerConfig);
+    private isDisabled;
+    private readonly overlayService;
+    private readonly viewContainerRef;
+    private readonly renderer;
+    constructor(el: ElementRef<HTMLInputElement>);
+    updateConfig(val: NgxDatePickerConfig): void;
+    ngOnDestroy(): void;
+    onClick(ev: Event): void;
+    onInput(event: Event): void;
+    onBlur(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    toggle(): void;
+    private destroyDatePicker;
+    private emitChange;
+    validate(control: AbstractControl): ValidationErrors | null;
+    /** Formats a value and sets it on the input element. */
+    protected _formatValue(value: Date | null, setChange?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputDatePicker, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxInputDatePicker, "[ngxInputDatePicker]", ["ngxInputDatePicker"], { "theme": { "alias": "theme"; "required": false; }; "openOnCLick": { "alias": "openOnCLick"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "setMin": { "alias": "min"; "required": false; }; "setMax": { "alias": "max"; "required": false; }; "setConfig": { "alias": "config"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+declare class MsEvents<DateInput = Date> {
+    title?: string;
+    start: DateInput;
+    end?: DateInput;
+}
+
+declare class DateModel<InputDate = Date> {
+    date?: InputDate;
+    active?: boolean;
+    isToday?: boolean;
+    selected?: boolean;
+}
+declare class DateViewYear extends DateModel {
+    year: number;
+}
+declare class DateViewMonth extends DateModel {
+    month: number;
+    displayMonth: string;
+}
+declare class DateViewDay extends DateModel {
+    day: number;
+    events?: MsEvents[];
+}
+declare class DateViewWeek extends DateModel {
+    time: number;
+    weeks: string[];
+    displayTime: string;
+}
+
+declare abstract class NgxDatePickerBase {
+    protected _locale: string;
+    protected dateAdapterRegistry: DateAdapterRegistry;
+    adapter: IDateAdapter;
+    currYear: number;
+    currMonth: number;
+    currentWeek: number;
+    months: string[];
+    weeks: string[];
+    viewDays: DateViewDay[];
+    viewMonths: DateViewMonth[];
+    viewYears: DateViewYear[];
+    viewWeeks: DateViewWeek[];
+    displayMonth: string;
+    minDate: Date | null;
+    maxDate: Date | null;
+    renderCalendar(view: CalendarView | DatePickerView, selected?: CalendarDate, events?: MsEvents[], callback?: Function): void;
+    renderYear(): void;
+    renderMonth(): void;
+    /** only in calendar view */
+    renderWeek(): void;
+    renderDay(selected?: CalendarDate, _events?: MsEvents[]): void;
+    checkActiveDate(date: Date): boolean;
+    checkActiveMonth(year: number, month: number): boolean;
+    checkActiveYear(year: number): boolean;
+    private getEvents;
+}
+
+interface ISelectedEvent {
+    date: Date;
+    event: MsEvents;
+}
+
+declare class NgxCalendarComponent extends NgxDatePickerBase implements OnInit, AfterViewInit {
+    protected readonly browserService: BrowserService;
+    theme: 'light' | 'dark';
+    set setTheme(val: 'light' | 'dark' | 'auto');
+    _config: NgxDatePickerConfig;
+    set config(val: NgxDatePickerConfig);
+    set locale(val: string);
+    /** The minimum valid date. */
+    set setMin(value: Date | null | undefined);
+    /** The maximum valid date. */
+    set setMax(value: Date | null | undefined);
+    view: CalendarView;
+    _events: MsEvents[];
+    set events(val: MsEvents[]);
+    dateChange: EventEmitter<DateViewDay>;
+    selectEvent: EventEmitter<ISelectedEvent>;
+    defaultHeight: number;
+    minHeight: number;
+    selected?: Date;
+    calendarWrapper: i0.Signal<ElementRef<HTMLElement> | undefined>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onResize(ev: Event): void;
+    calcCellSize(): void;
+    renderCalendar(view: CalendarView): void;
+    changeView(v: CalendarView): void;
+    gotoToday(): void;
+    selectDay(ev: Event, item: DateViewDay): void;
+    selectMonth(ev: Event, item: DateViewMonth): void;
+    selectYear(ev: Event, item: DateViewYear): void;
+    next(): void;
+    previous(): void;
+    onclickEvent(item: DateViewDay, event: MsEvents): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxCalendarComponent, "ngx-calendar", never, { "setTheme": { "alias": "theme"; "required": false; }; "config": { "alias": "config"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "setMin": { "alias": "min"; "required": false; }; "setMax": { "alias": "max"; "required": false; }; "view": { "alias": "view"; "required": false; }; "events": { "alias": "events"; "required": false; }; }, { "dateChange": "dateChange"; "selectEvent": "selectEvent"; }, never, never, true, never>;
+}
+
+declare class NgxInputDatePickerComponent extends NgxDatePickerBase implements ControlValueAccessor, Validator, OnInit {
+    protected readonly browserService: BrowserService;
+    theme: 'light' | 'dark';
+    set setTheme(val: 'light' | 'dark' | 'auto');
+    config: NgxDatePickerConfig;
+    set setConfig(val: NgxDatePickerConfig);
+    set locale(val: string);
+    /** The minimum valid date. */
+    set setMin(value: Date | null | undefined);
+    /** The maximum valid date. */
+    set setMax(value: Date | null | undefined);
+    view: DatePickerView;
+    change: EventEmitter<Date | null>;
+    wrapperWidth: number;
+    selected?: CalendarDate;
+    calendarHeader: string;
+    isDisabled: boolean;
+    weekDays: {
+        min: string;
+        name: string;
+    }[];
+    protected _onChange: (value: Date) => void;
+    protected _onTouched: () => void;
+    protected _validatorOnChange: () => void;
+    constructor();
+    ngOnInit(): void;
+    updateConfig(val: NgxDatePickerConfig): void;
+    init(): void;
+    writeValue(value: any): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    registerOnValidatorChange?(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    renderCalendar(view: 'year' | 'month' | 'day'): void;
+    gotoToday(): void;
+    changeView(v: DatePickerView): void;
+    next(): void;
+    previous(): void;
+    selectDay(ev: Event, item: DateViewDay): void;
+    selectMonth(ev: Event, item: DateViewMonth): void;
+    selectYear(ev: Event, item: DateViewYear): void;
+    clear(): void;
+    stopPagination(ev: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputDatePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxInputDatePickerComponent, "ngx-datepicker", never, { "setTheme": { "alias": "theme"; "required": false; }; "setConfig": { "alias": "config"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "setMin": { "alias": "min"; "required": false; }; "setMax": { "alias": "max"; "required": false; }; "view": { "alias": "view"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+declare function provideDateAdapters(...additional: DateAdapterRegistration[]): Provider[];
+
+export { DATE_ADAPTERS, DEFAULT_DATE_ADAPTERS, NgxCalendarComponent, NgxDatePickerConfig, NgxInputDatePicker, NgxInputDatePickerComponent, getLocals, provideDateAdapters };
+export type { CalendarDate, DateAdapterRegistration, IDateAdapter };

package/types/ngx-kit-dialog.d.ts

@@ -0,0 +1,139 @@
+import * as i0 from '@angular/core';
+import { Injector, ElementRef, OnInit, AfterViewInit, OnDestroy, Type, ComponentRef, ApplicationRef, EnvironmentInjector, Renderer2, InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as i5 from '@angular/common';
+
+declare class NgxDialogConfig<DataType = any> {
+    /**
+     * pass data to dialog
+     */
+    data?: DataType | any;
+    /** close dialog on outside click
+     * - default false */
+    allowCloseOnOutsideClick?: boolean;
+    /**
+     * container class
+     * - You can separate the list of classes with a space
+     * - for example:"`my class one two three ...`"
+     *
+     * TODO: must set with public config setter
+     */
+    containerClass?: string | undefined;
+    header?: {
+        enable?: true;
+        title?: '';
+        showCloseButton?: true;
+    };
+    footer?: {
+        enable?: true;
+    };
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    height?: string;
+    minHeight?: string;
+    maxHeight?: string;
+    /** parent injector */
+    injector?: Injector;
+    constructor();
+}
+
+declare class NgxDialogRef {
+    dialog?: ElementRef<HTMLElement>;
+    header?: ElementRef<HTMLElement>;
+    footer?: ElementRef<HTMLElement>;
+    body?: ElementRef<HTMLElement>;
+    private readonly _afterClosed;
+    afterClosed: Observable<any>;
+    id?: string;
+    close(result?: any): void;
+}
+
+declare class NgxDialogComponent implements OnInit, AfterViewInit, OnDestroy {
+    config?: NgxDialogConfig;
+    component: Type<any>;
+    private readonly _onClose;
+    onClose: rxjs.Observable<void>;
+    ngxDialog?: ElementRef<HTMLElement>;
+    _dialogRef: NgxDialogRef;
+    private cd;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onOverlayClicked(evt: MouseEvent): void;
+    onDialogClicked(evt: MouseEvent): void;
+    close(): void;
+    setStyle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxDialogComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class NgxOverlayService {
+    private appRef;
+    private injector;
+    private envInjector;
+    dialogComponentRefs: ComponentRef<NgxDialogComponent>[];
+    _defaultOptions: NgxDialogConfig | undefined;
+    constructor(appRef: ApplicationRef, injector: Injector, envInjector: EnvironmentInjector);
+    open(component: Type<any>, config?: NgxDialogConfig): NgxDialogRef;
+    private _open;
+    private removeDialogComponentFromBody;
+    private appendDialogComponentToBody;
+    closeAll(): void;
+    private get getDialogId();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxOverlayService>;
+}
+
+declare class NgxDialogHeaderDirective implements OnInit {
+    _el: ElementRef<HTMLElement>;
+    private _document;
+    showCloseButton: boolean;
+    private _dialogRef;
+    constructor(_el: ElementRef<HTMLElement>, _document: Document);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDialogHeaderDirective, "ngx-dialog-header,[ngxDialogHeader]", ["ngxDialogHeader"], { "showCloseButton": { "alias": "showCloseButton"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NgxDialogFooterDirective implements OnInit {
+    _el: ElementRef<HTMLElement>;
+    align: 'start' | 'end' | 'space-between' | 'center' | 'space-around';
+    private _dialogRef;
+    constructor(_el: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDialogFooterDirective, "ngx-dialog-footer,[ngxDialogFooter]", ["ngxDialogFooter"], { "align": { "alias": "align"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NgxDialogBodyDirective implements AfterViewInit {
+    _el: ElementRef<HTMLElement>;
+    private _renderer;
+    height?: number;
+    private _dialogRef;
+    constructor(_el: ElementRef<HTMLElement>, _renderer: Renderer2);
+    ngAfterViewInit(): void;
+    onWindowResize(ev?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDialogBodyDirective, "ngx-dialog-body,[ngxDialogBody]", ["ngxDialogBody"], {}, {}, never, never, false, never>;
+}
+
+declare class NgxDialogModule {
+    constructor(parentModule: NgxDialogModule | null, service: NgxOverlayService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogModule, [{ optional: true; skipSelf: true; }, null]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDialogModule, [typeof NgxDialogComponent, typeof NgxDialogHeaderDirective, typeof NgxDialogFooterDirective, typeof NgxDialogBodyDirective], [typeof i5.CommonModule], [typeof NgxDialogComponent, typeof NgxDialogHeaderDirective, typeof NgxDialogFooterDirective, typeof NgxDialogBodyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxDialogModule>;
+}
+
+declare class Dialog {
+    private static serviceInstance;
+    static _setService(svc: NgxOverlayService): void;
+    static open<DataType>(component: Type<any>, config?: NgxDialogConfig<DataType>): NgxDialogRef;
+}
+
+declare const DIALOG_DATA: InjectionToken<any>;
+declare const DIALOG_REF: InjectionToken<NgxDialogRef>;
+
+export { DIALOG_DATA, DIALOG_REF, Dialog, NgxDialogBodyDirective, NgxDialogComponent, NgxDialogConfig, NgxDialogFooterDirective, NgxDialogHeaderDirective, NgxDialogModule };

package/types/{ngx-input-gradient-picker.d.ts → ngx-kit-gradient-picker.d.ts}

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { OnInit, OnDestroy, EventEmitter, ChangeDetectorRef, AfterViewInit, ElementRef, Renderer2, ViewContainerRef } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
-import { BrowserService, RangeSliderComponent, DialogService } from 'ngx-input/shared';
+import { BrowserService, RangeSliderComponent, OverlayService } from 'ngx-kit/shared';
 
 interface GradientStop {
     id: string;
@@ -24,8 +24,8 @@ declare class NgxInputGradientComponent implements OnInit, OnDestroy, ControlVal
     rotation: number;
     selectedIndex: number;
     isDisabled: boolean;
-    _onChange: (value: string) => void;
-    _onTouched: () => void;
+    protected _onChange: (value: string) => void;
+    protected _onTouched: () => void;
     _onValidateChange: () => void;
     rangeSlider?: RangeSliderComponent;
     constructor(cd: ChangeDetectorRef);
@@ -53,7 +53,7 @@ declare class NgxInputGradient implements AfterViewInit, OnDestroy, ControlValue
     private el;
     private renderer;
     private viewContainerRef;
-    private dialogService;
+    private overlayService;
     setInputBackground: boolean;
     theme: 'light' | 'dark' | 'auto';
     private _targetInput?;
@@ -63,10 +63,10 @@ declare class NgxInputGradient implements AfterViewInit, OnDestroy, ControlValue
     private isHostInput;
     private pickerRef?;
     value: string;
-    _onChange: (value: string) => void;
-    _onTouched: () => void;
+    protected _onChange: (value: string) => void;
+    protected _onTouched: () => void;
     _onValidateChange: () => void;
-    constructor(el: ElementRef<HTMLInputElement>, renderer: Renderer2, viewContainerRef: ViewContainerRef, dialogService: DialogService);
+    constructor(el: ElementRef<HTMLInputElement>, renderer: Renderer2, viewContainerRef: ViewContainerRef, overlayService: OverlayService);
     onClick(ev: Event): void;
     ngAfterViewInit(): void;
     registerOnChange(fn: any): void;

package/types/ngx-kit-menu.d.ts

@@ -0,0 +1,69 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, OnDestroy, ElementRef, ApplicationRef } from '@angular/core';
+import { OverlayRef, Placement, Alignment, OverlayService } from 'ngx-kit/shared';
+
+interface MenuContext {
+    close(): void;
+}
+
+declare class NgxMenuPanel implements MenuContext {
+    template: i0.Signal<TemplateRef<any> | undefined>;
+    class: i0.InputSignal<string | undefined>;
+    containerRef?: OverlayRef<NgxMenuPanel>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMenuPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMenuPanel, "ngx-menu,[ngx-menu]", ["NgxMenu"], { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NgxMenu implements OnDestroy {
+    private el;
+    private appRef;
+    private overlayService;
+    ngxMenu: i0.InputSignal<NgxMenuPanel>;
+    placement: i0.InputSignal<Placement | undefined>;
+    alignment: i0.InputSignal<Alignment | undefined>;
+    private containerRef?;
+    constructor(el: ElementRef, appRef: ApplicationRef, overlayService: OverlayService);
+    ngOnDestroy(): void;
+    onClick(ev: Event): void;
+    private toggleContainer;
+    private destroyContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMenu, "[ngxMenu]", ["ngxMenu"], { "ngxMenu": { "alias": "ngxMenu"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgxContextMenu implements OnDestroy {
+    private el;
+    private appRef;
+    private overlayService;
+    ngxContextMenu: i0.InputSignal<NgxMenuPanel>;
+    private containerRef?;
+    constructor(el: ElementRef<HTMLElement>, appRef: ApplicationRef, overlayService: OverlayService);
+    ngOnDestroy(): void;
+    onClick(ev: PointerEvent): void;
+    private toggleContainer;
+    private destroyContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxContextMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxContextMenu, "[ngxContextMenu]", ["ngxContextMenu"], { "ngxContextMenu": { "alias": "ngxContextMenu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgxMenuItem {
+    menuContext: MenuContext;
+    childMenu: NgxMenu | null;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMenuItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMenuItem, "ngx-menu-item,[ngx-menu-item]", ["NgxMenuItem"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class NgxMenuDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMenuDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMenuDivider, "ngx-menu-divider", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgxMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMenuModule, never, [typeof NgxMenu, typeof NgxContextMenu, typeof NgxMenuPanel, typeof NgxMenuItem, typeof NgxMenuDivider], [typeof NgxMenu, typeof NgxContextMenu, typeof NgxMenuPanel, typeof NgxMenuItem, typeof NgxMenuDivider]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMenuModule>;
+}
+
+export { NgxContextMenu, NgxMenu, NgxMenuDivider, NgxMenuItem, NgxMenuModule, NgxMenuPanel };

package/types/ngx-kit-notify.d.ts

@@ -0,0 +1,60 @@
+import { EnvironmentProviders, Injector } from '@angular/core';
+
+interface NgxNotifyOptions {
+    /**
+     * Time out (ms)
+     * - @default 3000
+     */
+    timeout?: number;
+    /**
+     * Notify position
+     * @default top-center
+     */
+    position?: 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center';
+    /**
+     * How many visible at once
+     * queued, prevents overlap
+     * @default 10
+     */
+    maxVisible?: number;
+    /**
+     * Whether message may contain HTML
+     * @default false
+     */
+    allowHtml?: boolean;
+    /**
+     * Pause timeout when hovered
+     * @default true
+     */
+    pauseOnHover?: boolean;
+    /**
+     * Show close button
+     * @default true
+     */
+    dismissible?: boolean;
+    /**
+     * Additional container class
+     */
+    containerClass?: string;
+    /**
+     * Additional notification class
+     */
+    notificationClass?: string;
+}
+
+declare function provideNotify(options?: NgxNotifyOptions): EnvironmentProviders;
+
+/**
+ * Static facade so call sites can use: Notify.warn('msg', opts)
+ * Module will set the service instance in its constructor.
+ */
+declare class Notify {
+    static injector: Injector;
+    static show(message: string, type?: 'info' | 'success' | 'warning' | 'error', options?: NgxNotifyOptions): void;
+    static info(message: string, options?: NgxNotifyOptions): void;
+    static success(message: string, options?: NgxNotifyOptions): void;
+    static warning(message: string, options?: NgxNotifyOptions): void;
+    static error(message: string, options?: NgxNotifyOptions): void;
+}
+
+export { Notify, provideNotify };