@openmrs/ngx-formentry 3.0.0

package/components/ngx-pick-datetime/lib/date-time/date-time-picker-trigger.directive.d.ts

@@ -0,0 +1,20 @@
+import { AfterContentInit, ChangeDetectorRef, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { OwlDateTimeComponent } from './date-time-picker.component';
+import * as i0 from "@angular/core";
+export declare class OwlDateTimeTriggerDirective<T> implements OnChanges, AfterContentInit, OnDestroy {
+    protected changeDetector: ChangeDetectorRef;
+    dtPicker: OwlDateTimeComponent<T>;
+    get owlDTTriggerDisabledClass(): boolean;
+    handleClickOnHost($event: Event): void;
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private stateChanges;
+    constructor(changeDetector: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private watchStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OwlDateTimeTriggerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OwlDateTimeTriggerDirective<any>, "[ofeOwlDateTimeTrigger]", never, { "dtPicker": "ofeOwlDateTimeTrigger"; "disabled": "disabled"; }, {}, never>;
+}

package/components/ngx-pick-datetime/lib/date-time/date-time-picker.animations.d.ts

@@ -0,0 +1,8 @@
+/**
+ * date-time-picker.animations
+ */
+import { AnimationTriggerMetadata } from '@angular/animations';
+export declare const owlDateTimePickerAnimations: {
+    readonly transformPicker: AnimationTriggerMetadata;
+    readonly fadeInPicker: AnimationTriggerMetadata;
+};

package/components/ngx-pick-datetime/lib/date-time/date-time-picker.component.d.ts

@@ -0,0 +1,156 @@
+import { ChangeDetectorRef, EventEmitter, InjectionToken, NgZone, OnDestroy, ViewContainerRef } from '@angular/core';
+import { BlockScrollStrategy, Overlay, ScrollStrategy } from '@angular/cdk/overlay';
+import { OwlDateTimeInputDirective } from './date-time-picker-input.directive';
+import { DateTimeAdapter } from './adapter/date-time-adapter.class';
+import { OwlDateTimeFormats } from './adapter/date-time-format.class';
+import { OwlDateTime, PickerMode, PickerType, SelectMode } from './date-time.class';
+import { OwlDialogService } from '../dialog/dialog.service';
+import * as i0 from "@angular/core";
+/** Injection token that determines the scroll handling while the dtPicker is open. */
+export declare const OWL_DTPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+export declare function OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => BlockScrollStrategy;
+/** @docs-private */
+export declare const OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY;
+};
+export declare class OwlDateTimeComponent<T> extends OwlDateTime<T> implements OnDestroy {
+    private overlay;
+    private viewContainerRef;
+    private dialogService;
+    private ngZone;
+    protected changeDetector: ChangeDetectorRef;
+    protected dateTimeAdapter: DateTimeAdapter<T>;
+    protected dateTimeFormats: OwlDateTimeFormats;
+    private document;
+    /** Custom class for the picker backdrop. */
+    backdropClass: string | string[];
+    /** Custom class for the picker overlay pane. */
+    panelClass: string | string[];
+    /** The date to open the calendar to initially. */
+    private _startAt;
+    get startAt(): T | null;
+    set startAt(date: T | null);
+    /**
+     * Set the type of the dateTime picker
+     *      'both' -- show both calendar and timer
+     *      'calendar' -- show only calendar
+     *      'timer' -- show only timer
+     */
+    private _pickerType;
+    get pickerType(): PickerType;
+    set pickerType(val: PickerType);
+    /**
+     * Whether the picker open as a dialog
+     */
+    _pickerMode: PickerMode;
+    get pickerMode(): PickerMode;
+    set pickerMode(mode: PickerMode);
+    /** Whether the date time picker should be disabled. */
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Whether the calendar is open. */
+    private _opened;
+    get opened(): boolean;
+    set opened(val: boolean);
+    /**
+     * The scroll strategy when the picker is open
+     * Learn more this from https://material.angular.io/cdk/overlay/overview#scroll-strategies
+     * */
+    scrollStrategy: ScrollStrategy;
+    /**
+     * Callback when the picker is closed
+     * */
+    afterPickerClosed: EventEmitter<any>;
+    /**
+     * Callback when the picker is open
+     * */
+    afterPickerOpen: EventEmitter<any>;
+    /**
+     * Emits selected year in multi-year view
+     * This doesn't imply a change on the selected date.
+     * */
+    yearSelected: EventEmitter<T>;
+    /**
+     * Emits selected month in year view
+     * This doesn't imply a change on the selected date.
+     * */
+    monthSelected: EventEmitter<T>;
+    /**
+     * Emit when the selected value has been confirmed
+     * */
+    confirmSelectedChange: EventEmitter<T | T[]>;
+    /**
+     * Emits when the date time picker is disabled.
+     * */
+    disabledChange: EventEmitter<boolean>;
+    private pickerContainerPortal;
+    private pickerContainer;
+    private popupRef;
+    private dialogRef;
+    private dtInputSub;
+    private hidePickerStreamSub;
+    private confirmSelectedStreamSub;
+    private pickerOpenedStreamSub;
+    /** The element that was focused before the date time picker was opened. */
+    private focusedElementBeforeOpen;
+    private _dtInput;
+    get dtInput(): OwlDateTimeInputDirective<T>;
+    private _selected;
+    get selected(): T | null;
+    set selected(value: T | null);
+    private _selecteds;
+    get selecteds(): T[];
+    set selecteds(values: T[]);
+    /** The minimum selectable date. */
+    get minDateTime(): T | null;
+    /** The maximum selectable date. */
+    get maxDateTime(): T | null;
+    get dateTimeFilter(): (date: T | null) => boolean;
+    get selectMode(): SelectMode;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    private defaultScrollStrategy;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, dialogService: OwlDialogService, ngZone: NgZone, changeDetector: ChangeDetectorRef, dateTimeAdapter: DateTimeAdapter<T>, defaultScrollStrategy: any, dateTimeFormats: OwlDateTimeFormats, document: any);
+    ngOnDestroy(): void;
+    registerInput(input: OwlDateTimeInputDirective<T>): void;
+    open(): void;
+    /**
+     * Selects the given date
+     */
+    select(date: T[] | T): void;
+    /**
+     * Emits the selected year in multi-year view
+     * */
+    selectYear(normalizedYear: T): void;
+    /**
+     * Emits selected month in year view
+     * */
+    selectMonth(normalizedMonth: T): void;
+    /**
+     * Hide the picker
+     */
+    close(): void;
+    /**
+     * Confirm the selected value
+     */
+    confirmSelect(event?: any): void;
+    /**
+     * Open the picker as a dialog
+     */
+    private openAsDialog;
+    /**
+     * Open the picker as popup
+     */
+    private openAsPopup;
+    private createPopup;
+    /**
+     * Create the popup PositionStrategy.
+     * */
+    private createPopupPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OwlDateTimeComponent<any>, [null, null, null, null, null, { optional: true; }, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OwlDateTimeComponent<any>, "ofe-owl-date-time", ["owlDateTime"], { "backdropClass": "backdropClass"; "panelClass": "panelClass"; "startAt": "startAt"; "pickerType": "pickerType"; "pickerMode": "pickerMode"; "disabled": "disabled"; "opened": "opened"; "scrollStrategy": "scrollStrategy"; }, { "afterPickerClosed": "afterPickerClosed"; "afterPickerOpen": "afterPickerOpen"; "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; }, never, never>;
+}

package/components/ngx-pick-datetime/lib/date-time/date-time.class.d.ts

@@ -0,0 +1,89 @@
+/**
+ * date-time.class
+ */
+import { EventEmitter } from '@angular/core';
+import { DateTimeAdapter } from './adapter/date-time-adapter.class';
+import { OwlDateTimeFormats } from './adapter/date-time-format.class';
+import * as i0 from "@angular/core";
+export declare type PickerType = 'both' | 'calendar' | 'timer';
+export declare type PickerMode = 'popup' | 'dialog' | 'inline';
+export declare type SelectMode = 'single' | 'range' | 'rangeFrom' | 'rangeTo';
+export declare abstract class OwlDateTime<T> {
+    protected dateTimeAdapter: DateTimeAdapter<T>;
+    protected dateTimeFormats: OwlDateTimeFormats;
+    get showSecondsTimer(): boolean;
+    set showSecondsTimer(val: boolean);
+    get hour12Timer(): boolean;
+    set hour12Timer(val: boolean);
+    get stepHour(): number;
+    set stepHour(val: number);
+    get stepMinute(): number;
+    set stepMinute(val: number);
+    get stepSecond(): number;
+    set stepSecond(val: number);
+    get firstDayOfWeek(): number;
+    set firstDayOfWeek(value: number);
+    get hideOtherMonths(): boolean;
+    set hideOtherMonths(val: boolean);
+    get id(): string;
+    abstract get selected(): T | null;
+    abstract get selecteds(): T[] | null;
+    abstract get dateTimeFilter(): (date: T | null) => boolean;
+    abstract get maxDateTime(): T | null;
+    abstract get minDateTime(): T | null;
+    abstract get selectMode(): SelectMode;
+    abstract get startAt(): T | null;
+    abstract get opened(): boolean;
+    abstract get pickerMode(): PickerMode;
+    abstract get pickerType(): PickerType;
+    abstract get isInSingleMode(): boolean;
+    abstract get isInRangeMode(): boolean;
+    get formatString(): string;
+    get disabled(): boolean;
+    constructor(dateTimeAdapter: DateTimeAdapter<T>, dateTimeFormats: OwlDateTimeFormats);
+    /**
+     * Whether to show the second's timer
+     */
+    private _showSecondsTimer;
+    /**
+     * Whether the timer is in hour12 format
+     */
+    private _hour12Timer;
+    /**
+     * The view that the calendar should start in.
+     */
+    startView: 'month' | 'year' | 'multi-years';
+    /**
+     * Hours to change per step
+     */
+    private _stepHour;
+    /**
+     * Minutes to change per step
+     */
+    private _stepMinute;
+    /**
+     * Seconds to change per step
+     */
+    private _stepSecond;
+    /**
+     * Set the first day of week
+     */
+    private _firstDayOfWeek;
+    /**
+     * Whether to hide dates in other months at the start or end of the current month.
+     */
+    private _hideOtherMonths;
+    private _id;
+    abstract yearSelected: EventEmitter<T>;
+    abstract monthSelected: EventEmitter<T>;
+    abstract select(date: T | T[]): void;
+    abstract selectYear(normalizedYear: T): void;
+    abstract selectMonth(normalizedMonth: T): void;
+    /**
+     * Date Time Checker to check if the give dateTime is selectable
+     */
+    dateTimeChecker: (dateTime: T) => boolean;
+    protected getValidDate(obj: any): T | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OwlDateTime<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OwlDateTime<any>>;
+}

package/components/ngx-pick-datetime/lib/date-time/date-time.module.d.ts

@@ -0,0 +1,23 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./date-time-picker-trigger.directive";
+import * as i2 from "./date-time-picker-input.directive";
+import * as i3 from "./date-time-picker.component";
+import * as i4 from "./date-time-picker-container.component";
+import * as i5 from "./calendar-multi-year-view.component";
+import * as i6 from "./calendar-year-view.component";
+import * as i7 from "./calendar-month-view.component";
+import * as i8 from "./timer.component";
+import * as i9 from "./timer-box.component";
+import * as i10 from "./calendar.component";
+import * as i11 from "./calendar-body.component";
+import * as i12 from "./numberedFixLen.pipe";
+import * as i13 from "./date-time-inline.component";
+import * as i14 from "@angular/common";
+import * as i15 from "@angular/cdk/overlay";
+import * as i16 from "../dialog/dialog.module";
+import * as i17 from "@angular/cdk/a11y";
+export declare class OwlDateTimeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OwlDateTimeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OwlDateTimeModule, [typeof i1.OwlDateTimeTriggerDirective, typeof i2.OwlDateTimeInputDirective, typeof i3.OwlDateTimeComponent, typeof i4.OwlDateTimeContainerComponent, typeof i5.OwlMultiYearViewComponent, typeof i6.OwlYearViewComponent, typeof i7.OwlMonthViewComponent, typeof i8.OwlTimerComponent, typeof i9.OwlTimerBoxComponent, typeof i10.OwlCalendarComponent, typeof i11.OwlCalendarBodyComponent, typeof i12.NumberFixedLenPipe, typeof i13.OwlDateTimeInlineComponent], [typeof i14.CommonModule, typeof i15.OverlayModule, typeof i16.OwlDialogModule, typeof i17.A11yModule], [typeof i10.OwlCalendarComponent, typeof i8.OwlTimerComponent, typeof i1.OwlDateTimeTriggerDirective, typeof i2.OwlDateTimeInputDirective, typeof i3.OwlDateTimeComponent, typeof i13.OwlDateTimeInlineComponent, typeof i5.OwlMultiYearViewComponent, typeof i6.OwlYearViewComponent, typeof i7.OwlMonthViewComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OwlDateTimeModule>;
+}

package/components/ngx-pick-datetime/lib/date-time/numberedFixLen.pipe.d.ts

@@ -0,0 +1,10 @@
+/**
+ * numberFixedLen.pipe
+ */
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NumberFixedLenPipe implements PipeTransform {
+    transform(num: number, len: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFixedLenPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumberFixedLenPipe, "numberFixedLen">;
+}

package/components/ngx-pick-datetime/lib/date-time/timer-box.component.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class OwlTimerBoxComponent implements OnInit, OnDestroy {
+    get owlDTTimerBoxClass(): boolean;
+    showDivider: boolean;
+    upBtnAriaLabel: string;
+    upBtnDisabled: boolean;
+    downBtnAriaLabel: string;
+    downBtnDisabled: boolean;
+    /**
+     * Value would be displayed in the box
+     * If it is null, the box would display [value]
+     * */
+    boxValue: number;
+    value: number;
+    min: number;
+    max: number;
+    step: number;
+    inputLabel: string;
+    valueChange: EventEmitter<number>;
+    inputChange: EventEmitter<number>;
+    private inputStream;
+    private inputStreamSub;
+    get displayValue(): number;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    upBtnClicked(): void;
+    downBtnClicked(): void;
+    handleInputChange(val: string): void;
+    private updateValue;
+    private updateValueViaInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OwlTimerBoxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OwlTimerBoxComponent, "ofe-owl-date-time-timer-box", ["owlDateTimeTimerBox"], { "showDivider": "showDivider"; "upBtnAriaLabel": "upBtnAriaLabel"; "upBtnDisabled": "upBtnDisabled"; "downBtnAriaLabel": "downBtnAriaLabel"; "downBtnDisabled": "downBtnDisabled"; "boxValue": "boxValue"; "value": "value"; "min": "min"; "max": "max"; "step": "step"; "inputLabel": "inputLabel"; }, { "valueChange": "valueChange"; "inputChange": "inputChange"; }, never, never>;
+}

package/components/ngx-pick-datetime/lib/date-time/timer.component.d.ts

@@ -0,0 +1,128 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone } from '@angular/core';
+import { OwlDateTimeIntl } from './date-time-picker-intl.service';
+import { DateTimeAdapter } from './adapter/date-time-adapter.class';
+import * as i0 from "@angular/core";
+export declare class OwlTimerComponent<T> {
+    private ngZone;
+    private elmRef;
+    private pickerIntl;
+    private cdRef;
+    private dateTimeAdapter;
+    get owlDTTimeTabIndex(): number;
+    get owlDTTimerClass(): boolean;
+    /** The current picker moment */
+    private _pickerMoment;
+    get pickerMoment(): T;
+    set pickerMoment(value: T);
+    /** The minimum selectable date time. */
+    private _minDateTime;
+    get minDateTime(): T | null;
+    set minDateTime(value: T | null);
+    /** The maximum selectable date time. */
+    private _maxDateTime;
+    get maxDateTime(): T | null;
+    set maxDateTime(value: T | null);
+    private isPM;
+    /**
+     * Whether to show the second's timer
+     */
+    showSecondsTimer: boolean;
+    /**
+     * Whether the timer is in hour12 format
+     */
+    hour12Timer: boolean;
+    /**
+     * Hours to change per step
+     */
+    stepHour: number;
+    /**
+     * Minutes to change per step
+     */
+    stepMinute: number;
+    /**
+     * Seconds to change per step
+     */
+    stepSecond: number;
+    get hourValue(): number;
+    /**
+     * The value would be displayed in hourBox.
+     * We need this because the value displayed in hourBox it not
+     * the same as the hourValue when the timer is in hour12Timer mode.
+     * */
+    get hourBoxValue(): number;
+    get minuteValue(): number;
+    get secondValue(): number;
+    get upHourButtonLabel(): string;
+    get downHourButtonLabel(): string;
+    get upMinuteButtonLabel(): string;
+    get downMinuteButtonLabel(): string;
+    get upSecondButtonLabel(): string;
+    get downSecondButtonLabel(): string;
+    get hour12ButtonLabel(): string;
+    selectedChange: EventEmitter<T>;
+    constructor(ngZone: NgZone, elmRef: ElementRef, pickerIntl: OwlDateTimeIntl, cdRef: ChangeDetectorRef, dateTimeAdapter: DateTimeAdapter<T>);
+    /**
+     * Focus to the host element
+     * */
+    focus(): void;
+    /**
+     * Set the hour value via typing into timer box input
+     * We need this to handle the hour value when the timer is in hour12 mode
+     * */
+    setHourValueViaInput(hours: number): void;
+    setHourValue(hours: number): void;
+    setMinuteValue(minutes: number): void;
+    setSecondValue(seconds: number): void;
+    setMeridiem(event: any): void;
+    /**
+     * Check if the up hour button is enabled
+     */
+    upHourEnabled(): boolean;
+    /**
+     * Check if the down hour button is enabled
+     */
+    downHourEnabled(): boolean;
+    /**
+     * Check if the up minute button is enabled
+     */
+    upMinuteEnabled(): boolean;
+    /**
+     * Check if the down minute button is enabled
+     */
+    downMinuteEnabled(): boolean;
+    /**
+     * Check if the up second button is enabled
+     */
+    upSecondEnabled(): boolean;
+    /**
+     * Check if the down second button is enabled
+     */
+    downSecondEnabled(): boolean;
+    /**
+     * PickerMoment's hour value +/- certain amount and compare it to the give date
+     * 1 is after the comparedDate
+     * -1 is before the comparedDate
+     * 0 is equal the comparedDate
+     * */
+    private compareHours;
+    /**
+     * PickerMoment's minute value +/- certain amount and compare it to the give date
+     * 1 is after the comparedDate
+     * -1 is before the comparedDate
+     * 0 is equal the comparedDate
+     * */
+    private compareMinutes;
+    /**
+     * PickerMoment's second value +/- certain amount and compare it to the give date
+     * 1 is after the comparedDate
+     * -1 is before the comparedDate
+     * 0 is equal the comparedDate
+     * */
+    private compareSeconds;
+    /**
+     * Get a valid date object
+     */
+    private getValidDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OwlTimerComponent<any>, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OwlTimerComponent<any>, "ofe-owl-date-time-timer", ["owlDateTimeTimer"], { "pickerMoment": "pickerMoment"; "minDateTime": "minDateTime"; "maxDateTime": "maxDateTime"; "showSecondsTimer": "showSecondsTimer"; "hour12Timer": "hour12Timer"; "stepHour": "stepHour"; "stepMinute": "stepMinute"; "stepSecond": "stepSecond"; }, { "selectedChange": "selectedChange"; }, never, never>;
+}

package/components/ngx-pick-datetime/lib/dialog/dialog-config.class.d.ts

@@ -0,0 +1,93 @@
+/**
+ * dialog-config.class
+ */
+import { ViewContainerRef } from '@angular/core';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+/** Possible overrides for a dialog's position. */
+export interface DialogPosition {
+    /** Override for the dialog's top position. */
+    top?: string;
+    /** Override for the dialog's bottom position. */
+    bottom?: string;
+    /** Override for the dialog's left position. */
+    left?: string;
+    /** Override for the dialog's right position. */
+    right?: string;
+}
+export declare class OwlDialogConfig {
+    /**
+     * ID of the element that describes the dialog.
+     */
+    ariaDescribedBy?: string | null;
+    /**
+     * Whether to focus the dialog when the dialog is opened
+     */
+    autoFocus?: boolean;
+    /** Whether the dialog has a backdrop. */
+    hasBackdrop?: boolean;
+    /**
+     * Custom style for the backdrop
+     * */
+    backdropStyle?: any;
+    /** Data being injected into the child component. */
+    data?: any;
+    /** Whether the user can use escape or clicking outside to close a modal. */
+    disableClose?: boolean;
+    /**
+     * ID for the modal. If omitted, a unique one will be generated.
+     */
+    id?: string;
+    /**
+     * The ARIA role of the dialog element.
+     */
+    role?: 'dialog' | 'alertdialog';
+    /**
+     * Custom class for the pane
+     * */
+    paneClass?: string | string[];
+    /**
+     * Mouse Event
+     * */
+    event?: MouseEvent;
+    /**
+     * Custom class for the backdrop
+     * */
+    backdropClass?: string | string[];
+    /**
+     * Whether the dialog should close when the user goes backwards/forwards in history.
+     * */
+    closeOnNavigation: boolean;
+    /** Width of the dialog. */
+    width: string;
+    /** Height of the dialog. */
+    height: string;
+    /**
+     * The min-width of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    minWidth?: number | string;
+    /**
+     * The min-height of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    minHeight?: number | string;
+    /**
+     * The max-width of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    maxWidth?: number | string;
+    /**
+     * The max-height of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    maxHeight?: number | string;
+    /** Position overrides. */
+    position?: DialogPosition;
+    /**
+     * The scroll strategy when the dialog is open
+     * Learn more this from https://material.angular.io/cdk/overlay/overview#scroll-strategies
+     * */
+    scrollStrategy?: ScrollStrategy;
+    viewContainerRef?: ViewContainerRef;
+    constructor();
+}

package/components/ngx-pick-datetime/lib/dialog/dialog-container.component.d.ts

@@ -0,0 +1,58 @@
+import { ChangeDetectorRef, ComponentRef, ElementRef, EmbeddedViewRef, EventEmitter } from '@angular/core';
+import { AnimationEvent } from '@angular/animations';
+import { FocusTrapFactory } from '@angular/cdk/a11y';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { OwlDialogConfig } from './dialog-config.class';
+import * as i0 from "@angular/core";
+export declare class OwlDialogContainerComponent extends BasePortalOutlet {
+    private changeDetector;
+    private elementRef;
+    private focusTrapFactory;
+    private document;
+    get owlDialogContainerTabIndex(): number;
+    get owlDialogContainerClass(): boolean;
+    get owlDialogContainerId(): string;
+    get owlDialogContainerRole(): "dialog" | "alertdialog";
+    get owlDialogContainerAriaLabelledby(): string;
+    get owlDialogContainerAriaDescribedby(): string;
+    get owlDialogContainerAnimation(): {
+        value: "enter" | "exit" | "void";
+        params: any;
+    };
+    onAnimationStart(event: AnimationEvent): void;
+    onAnimationDone(event: AnimationEvent): void;
+    portalOutlet: CdkPortalOutlet;
+    /** The class that traps and manages focus within the dialog. */
+    private focusTrap;
+    /** ID of the element that should be considered as the dialog's label. */
+    ariaLabelledBy: string | null;
+    /** Emits when an animation state changes. */
+    animationStateChanged: EventEmitter<AnimationEvent>;
+    isAnimating: boolean;
+    private _config;
+    get config(): OwlDialogConfig;
+    private state;
+    private params;
+    private elementFocusedBeforeDialogWasOpened;
+    constructor(changeDetector: ChangeDetectorRef, elementRef: ElementRef, focusTrapFactory: FocusTrapFactory, document: any);
+    /**
+     * Attach a ComponentPortal as content to this dialog container.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    setConfig(config: OwlDialogConfig): void;
+    startExitAnimation(): void;
+    /**
+     * Calculate origin used in the `zoomFadeInFrom()`
+     * for animation purpose
+     */
+    private calculateZoomOrigin;
+    /**
+     * Save the focused element before dialog was open
+     */
+    private savePreviouslyFocusedElement;
+    private trapFocus;
+    private restoreFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OwlDialogContainerComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OwlDialogContainerComponent, "ofe-owl-dialog-container", never, {}, {}, never, never>;
+}

package/components/ngx-pick-datetime/lib/dialog/dialog-ref.class.d.ts

@@ -0,0 +1,49 @@
+import { Location } from '@angular/common';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { OwlDialogContainerComponent } from './dialog-container.component';
+import { DialogPosition } from './dialog-config.class';
+import { Observable } from 'rxjs';
+export declare class OwlDialogRef<T> {
+    private overlayRef;
+    private container;
+    readonly id: string;
+    private result;
+    private _beforeClose$;
+    private _afterOpen$;
+    private _afterClosed$;
+    /** Subscription to changes in the user's location. */
+    private locationChanged;
+    /**
+     * The instance of component opened into modal
+     * */
+    componentInstance: T;
+    /** Whether the user is allowed to close the dialog. */
+    disableClose: boolean;
+    constructor(overlayRef: OverlayRef, container: OwlDialogContainerComponent, id: string, location?: Location);
+    close(dialogResult?: any): void;
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick(): Observable<any>;
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * Updates the dialog's position.
+     * @param position New dialog position.
+     */
+    updatePosition(position?: DialogPosition): this;
+    /**
+     * Updates the dialog's width and height.
+     * @param width New width of the dialog.
+     * @param height New height of the dialog.
+     */
+    updateSize(width?: string, height?: string): this;
+    isAnimating(): boolean;
+    afterOpen(): Observable<any>;
+    beforeClose(): Observable<any>;
+    afterClosed(): Observable<any>;
+    /** Fetches the position strategy object from the overlay ref. */
+    private getPositionStrategy;
+}