@ui5/webcomponents-ngx 0.0.1-rc.0

package/main/directives/color-palette-item.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ColorPaletteItem.js';
+import * as i0 from "@angular/core";
+interface ColorPaletteItemDirectiveElement extends Omit<HTMLElement, 'value'> {
+    value: any;
+}
+declare class ColorPaletteItemDirective {
+    private elementRef;
+    set value(val: ColorPaletteItemDirectiveElement['value']);
+    get value(): ColorPaletteItemDirectiveElement['value'];
+    constructor(elementRef: ElementRef<ColorPaletteItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPaletteItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPaletteItemDirective, "ui5-color-palette-item", ["ui5ColorPaletteItem"], { "value": "value"; }, {}, never, never, false, never>;
+}
+export { ColorPaletteItemDirective, ColorPaletteItemDirectiveElement };

package/main/directives/color-palette-popover.d.ts

@@ -0,0 +1,42 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ColorPalettePopover.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ColorPalettePopoverDirectiveEventsMap extends Omit<HTMLElementEventMap, 'itemClick'> {
+    itemClick: CustomEvent<{
+        color: string;
+    }>;
+}
+interface ColorPalettePopoverDirectiveElement extends Omit<HTMLElement, 'defaultColor' | 'showDefaultColor' | 'showMoreColors' | 'showRecentColors' | 'itemClick'> {
+    defaultColor: any;
+    showDefaultColor: boolean;
+    showMoreColors: boolean;
+    showRecentColors: boolean;
+    addEventListener<K extends keyof ColorPalettePopoverDirectiveEventsMap>(type: K, listener: (this: ColorPalettePopoverDirectiveElement, ev: ColorPalettePopoverDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ColorPalettePopoverDirectiveEventsMap>(type: K, listener: (this: ColorPalettePopoverDirectiveElement, ev: ColorPalettePopoverDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    isOpen(): boolean;
+    openPopover(opener: HTMLElement): any;
+    showAt(opener: HTMLElement): any;
+}
+declare class ColorPalettePopoverDirective {
+    private elementRef;
+    set defaultColor(val: ColorPalettePopoverDirectiveElement['defaultColor']);
+    get defaultColor(): ColorPalettePopoverDirectiveElement['defaultColor'];
+    set showDefaultColor(val: ColorPalettePopoverDirectiveElement['showDefaultColor']);
+    get showDefaultColor(): ColorPalettePopoverDirectiveElement['showDefaultColor'];
+    set showMoreColors(val: ColorPalettePopoverDirectiveElement['showMoreColors']);
+    get showMoreColors(): ColorPalettePopoverDirectiveElement['showMoreColors'];
+    set showRecentColors(val: ColorPalettePopoverDirectiveElement['showRecentColors']);
+    get showRecentColors(): ColorPalettePopoverDirectiveElement['showRecentColors'];
+    itemClick: Observable<ColorPalettePopoverDirectiveEventsMap['itemClick']>;
+    constructor(elementRef: ElementRef<ColorPalettePopoverDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    isOpen(): boolean;
+    openPopover(opener: HTMLElement): any;
+    showAt(opener: HTMLElement): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPalettePopoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPalettePopoverDirective, "ui5-color-palette-popover", ["ui5ColorPalettePopover"], { "defaultColor": "defaultColor"; "showDefaultColor": "showDefaultColor"; "showMoreColors": "showMoreColors"; "showRecentColors": "showRecentColors"; }, { "itemClick": "itemClick"; }, never, never, false, never>;
+}
+export { ColorPalettePopoverDirective, ColorPalettePopoverDirectiveEventsMap, ColorPalettePopoverDirectiveElement, };

package/main/directives/color-palette.d.ts

@@ -0,0 +1,24 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ColorPalette.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ColorPaletteDirectiveEventsMap extends Omit<HTMLElementEventMap, 'itemClick'> {
+    itemClick: CustomEvent<{
+        color: string;
+    }>;
+}
+interface ColorPaletteDirectiveElement extends Omit<HTMLElement, 'itemClick'> {
+    addEventListener<K extends keyof ColorPaletteDirectiveEventsMap>(type: K, listener: (this: ColorPaletteDirectiveElement, ev: ColorPaletteDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ColorPaletteDirectiveEventsMap>(type: K, listener: (this: ColorPaletteDirectiveElement, ev: ColorPaletteDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class ColorPaletteDirective {
+    private elementRef;
+    itemClick: Observable<ColorPaletteDirectiveEventsMap['itemClick']>;
+    constructor(elementRef: ElementRef<ColorPaletteDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPaletteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPaletteDirective, "ui5-color-palette", ["ui5ColorPalette"], {}, { "itemClick": "itemClick"; }, never, never, false, never>;
+}
+export { ColorPaletteDirective, ColorPaletteDirectiveEventsMap, ColorPaletteDirectiveElement, };

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

@@ -0,0 +1,25 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ColorPicker.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ColorPickerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<void>;
+}
+interface ColorPickerDirectiveElement extends Omit<HTMLElement, 'color' | 'change'> {
+    color: any;
+    addEventListener<K extends keyof ColorPickerDirectiveEventsMap>(type: K, listener: (this: ColorPickerDirectiveElement, ev: ColorPickerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ColorPickerDirectiveEventsMap>(type: K, listener: (this: ColorPickerDirectiveElement, ev: ColorPickerDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class ColorPickerDirective {
+    private elementRef;
+    set color(val: ColorPickerDirectiveElement['color']);
+    get color(): ColorPickerDirectiveElement['color'];
+    change: Observable<ColorPickerDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<ColorPickerDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPickerDirective, "ui5-color-picker", ["ui5ColorPicker"], { "color": "color"; }, { "change": "change"; }, never, never, false, never>;
+}
+export { ColorPickerDirective, ColorPickerDirectiveEventsMap, ColorPickerDirectiveElement, };

package/main/directives/combo-box-group-item.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ComboBoxGroupItem.js';
+import * as i0 from "@angular/core";
+interface ComboBoxGroupItemDirectiveElement extends Omit<HTMLElement, 'text'> {
+    text: string;
+}
+declare class ComboBoxGroupItemDirective {
+    private elementRef;
+    set text(val: ComboBoxGroupItemDirectiveElement['text']);
+    get text(): ComboBoxGroupItemDirectiveElement['text'];
+    constructor(elementRef: ElementRef<ComboBoxGroupItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboBoxGroupItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboBoxGroupItemDirective, "ui5-cb-group-item", ["ui5CbGroupItem"], { "text": "text"; }, {}, never, never, false, never>;
+}
+export { ComboBoxGroupItemDirective, ComboBoxGroupItemDirectiveElement };

package/main/directives/combo-box-item.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ComboBoxItem.js';
+import * as i0 from "@angular/core";
+interface ComboBoxItemDirectiveElement extends Omit<HTMLElement, 'additionalText' | 'text'> {
+    additionalText: string;
+    text: string;
+}
+declare class ComboBoxItemDirective {
+    private elementRef;
+    set additionalText(val: ComboBoxItemDirectiveElement['additionalText']);
+    get additionalText(): ComboBoxItemDirectiveElement['additionalText'];
+    set text(val: ComboBoxItemDirectiveElement['text']);
+    get text(): ComboBoxItemDirectiveElement['text'];
+    constructor(elementRef: ElementRef<ComboBoxItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboBoxItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboBoxItemDirective, "ui5-cb-item", ["ui5CbItem"], { "additionalText": "additionalText"; "text": "text"; }, {}, never, never, false, never>;
+}
+export { ComboBoxItemDirective, ComboBoxItemDirectiveElement };

package/main/directives/combo-box.d.ts

@@ -0,0 +1,70 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ComboBox.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import { IconDirective } from './icon';
+import * as i0 from "@angular/core";
+interface ComboBoxDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input' | 'selectionChange'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+    selectionChange: CustomEvent<{
+        item: HTMLElement;
+    }>;
+}
+interface ComboBoxDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'filter' | 'loading' | 'placeholder' | 'readonly' | 'required' | 'value' | 'valueState' | 'change' | 'input' | 'selectionChange' | 'icon' | 'valueStateMessage'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    disabled: boolean;
+    filter: string;
+    loading: boolean;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    icon: IconDirective['element'];
+    valueStateMessage: Array<HTMLElement>;
+    addEventListener<K extends keyof ComboBoxDirectiveEventsMap>(type: K, listener: (this: ComboBoxDirectiveElement, ev: ComboBoxDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ComboBoxDirectiveEventsMap>(type: K, listener: (this: ComboBoxDirectiveElement, ev: ComboBoxDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class ComboBoxDirective {
+    private elementRef;
+    set accessibleName(val: ComboBoxDirectiveElement['accessibleName']);
+    get accessibleName(): ComboBoxDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: ComboBoxDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): ComboBoxDirectiveElement['accessibleNameRef'];
+    set disabled(val: ComboBoxDirectiveElement['disabled']);
+    get disabled(): ComboBoxDirectiveElement['disabled'];
+    set filter(val: ComboBoxDirectiveElement['filter']);
+    get filter(): ComboBoxDirectiveElement['filter'];
+    set loading(val: ComboBoxDirectiveElement['loading']);
+    get loading(): ComboBoxDirectiveElement['loading'];
+    set placeholder(val: ComboBoxDirectiveElement['placeholder']);
+    get placeholder(): ComboBoxDirectiveElement['placeholder'];
+    set readonly(val: ComboBoxDirectiveElement['readonly']);
+    get readonly(): ComboBoxDirectiveElement['readonly'];
+    set required(val: ComboBoxDirectiveElement['required']);
+    get required(): ComboBoxDirectiveElement['required'];
+    set value(val: ComboBoxDirectiveElement['value']);
+    get value(): ComboBoxDirectiveElement['value'];
+    set valueState(val: ComboBoxDirectiveElement['valueState']);
+    get valueState(): ComboBoxDirectiveElement['valueState'];
+    change: Observable<ComboBoxDirectiveEventsMap['change']>;
+    input: Observable<ComboBoxDirectiveEventsMap['input']>;
+    selectionChange: Observable<ComboBoxDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<ComboBoxDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get icon(): IconDirective['element'];
+    get valueStateMessage(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboBoxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboBoxDirective, "ui5-combobox", ["ui5Combobox"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "disabled": "disabled"; "filter": "filter"; "loading": "loading"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "value": "value"; "valueState": "valueState"; }, { "change": "change"; "input": "input"; "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+declare class ComboBoxDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<ComboBoxDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboBoxDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboBoxDirectiveCva, "ui5-combobox", never, {}, {}, never, never, false, never>;
+}
+export { ComboBoxDirective, ComboBoxDirectiveCva, ComboBoxDirectiveEventsMap, ComboBoxDirectiveElement, };

package/main/directives/custom-list-item.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/CustomListItem.js';
+import { Observable } from 'rxjs';
+import { ButtonDirective } from './button';
+import * as i0 from "@angular/core";
+interface CustomListItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'detailClick'> {
+    detailClick: CustomEvent<void>;
+}
+interface CustomListItemDirectiveElement extends Omit<HTMLElement, 'selected' | 'type' | 'accessibleName' | 'detailClick' | 'deleteButton'> {
+    selected: boolean;
+    type: 'Active' | 'Detail' | 'Inactive';
+    accessibleName: string;
+    deleteButton: ButtonDirective['element'];
+    addEventListener<K extends keyof CustomListItemDirectiveEventsMap>(type: K, listener: (this: CustomListItemDirectiveElement, ev: CustomListItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof CustomListItemDirectiveEventsMap>(type: K, listener: (this: CustomListItemDirectiveElement, ev: CustomListItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class CustomListItemDirective {
+    private elementRef;
+    set selected(val: CustomListItemDirectiveElement['selected']);
+    get selected(): CustomListItemDirectiveElement['selected'];
+    set type(val: CustomListItemDirectiveElement['type']);
+    get type(): CustomListItemDirectiveElement['type'];
+    set accessibleName(val: CustomListItemDirectiveElement['accessibleName']);
+    get accessibleName(): CustomListItemDirectiveElement['accessibleName'];
+    detailClick: Observable<CustomListItemDirectiveEventsMap['detailClick']>;
+    constructor(elementRef: ElementRef<CustomListItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get deleteButton(): ButtonDirective['element'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomListItemDirective, "ui5-li-custom", ["ui5LiCustom"], { "selected": "selected"; "type": "type"; "accessibleName": "accessibleName"; }, { "detailClick": "detailClick"; }, never, never, false, never>;
+}
+export { CustomListItemDirective, CustomListItemDirectiveEventsMap, CustomListItemDirectiveElement, };

package/main/directives/date-picker.d.ts

@@ -0,0 +1,115 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/DatePicker.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface DatePickerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<{
+        value: string;
+        valid: boolean;
+    }>;
+    input: CustomEvent<{
+        value: string;
+        valid: boolean;
+    }>;
+}
+interface DatePickerDirectiveElement extends Omit<HTMLElement, 'formatPattern' | 'maxDate' | 'minDate' | 'primaryCalendarType' | 'secondaryCalendarType' | 'accessibleName' | 'accessibleNameRef' | 'dateValue' | 'disabled' | 'hideWeekNumbers' | 'name' | 'placeholder' | 'readonly' | 'required' | 'value' | 'valueState' | 'change' | 'input' | 'valueStateMessage'> {
+    formatPattern: string;
+    maxDate: string;
+    minDate: string;
+    primaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    secondaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    accessibleName: string;
+    accessibleNameRef: string;
+    dateValue: any;
+    disabled: boolean;
+    hideWeekNumbers: boolean;
+    name: string;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    valueStateMessage: HTMLElement;
+    addEventListener<K extends keyof DatePickerDirectiveEventsMap>(type: K, listener: (this: DatePickerDirectiveElement, ev: DatePickerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof DatePickerDirectiveEventsMap>(type: K, listener: (this: DatePickerDirectiveElement, ev: DatePickerDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    _checkValueValidity(): any;
+    _modifyDateValue(amount: any, unit: any): any;
+    _onInputChange(): any;
+    _onInputInput(): any;
+    _onInputSubmit(): any;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isInValidRange(value: string): boolean;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    normalizeValue(): any;
+    onResponsivePopoverAfterClose(): any;
+    onSelectedDatesChange(event: any): any;
+    openPicker(): any;
+}
+declare class DatePickerDirective {
+    private elementRef;
+    set formatPattern(val: DatePickerDirectiveElement['formatPattern']);
+    get formatPattern(): DatePickerDirectiveElement['formatPattern'];
+    set maxDate(val: DatePickerDirectiveElement['maxDate']);
+    get maxDate(): DatePickerDirectiveElement['maxDate'];
+    set minDate(val: DatePickerDirectiveElement['minDate']);
+    get minDate(): DatePickerDirectiveElement['minDate'];
+    set primaryCalendarType(val: DatePickerDirectiveElement['primaryCalendarType']);
+    get primaryCalendarType(): DatePickerDirectiveElement['primaryCalendarType'];
+    set secondaryCalendarType(val: DatePickerDirectiveElement['secondaryCalendarType']);
+    get secondaryCalendarType(): DatePickerDirectiveElement['secondaryCalendarType'];
+    set accessibleName(val: DatePickerDirectiveElement['accessibleName']);
+    get accessibleName(): DatePickerDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: DatePickerDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): DatePickerDirectiveElement['accessibleNameRef'];
+    set dateValue(val: DatePickerDirectiveElement['dateValue']);
+    get dateValue(): DatePickerDirectiveElement['dateValue'];
+    set disabled(val: DatePickerDirectiveElement['disabled']);
+    get disabled(): DatePickerDirectiveElement['disabled'];
+    set hideWeekNumbers(val: DatePickerDirectiveElement['hideWeekNumbers']);
+    get hideWeekNumbers(): DatePickerDirectiveElement['hideWeekNumbers'];
+    set name(val: DatePickerDirectiveElement['name']);
+    get name(): DatePickerDirectiveElement['name'];
+    set placeholder(val: DatePickerDirectiveElement['placeholder']);
+    get placeholder(): DatePickerDirectiveElement['placeholder'];
+    set readonly(val: DatePickerDirectiveElement['readonly']);
+    get readonly(): DatePickerDirectiveElement['readonly'];
+    set required(val: DatePickerDirectiveElement['required']);
+    get required(): DatePickerDirectiveElement['required'];
+    set value(val: DatePickerDirectiveElement['value']);
+    get value(): DatePickerDirectiveElement['value'];
+    set valueState(val: DatePickerDirectiveElement['valueState']);
+    get valueState(): DatePickerDirectiveElement['valueState'];
+    change: Observable<DatePickerDirectiveEventsMap['change']>;
+    input: Observable<DatePickerDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<DatePickerDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): HTMLElement;
+    _checkValueValidity(): any;
+    _modifyDateValue(amount: any, unit: any): any;
+    _onInputChange(): any;
+    _onInputInput(): any;
+    _onInputSubmit(): any;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isInValidRange(value: string): boolean;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    normalizeValue(): any;
+    onResponsivePopoverAfterClose(): any;
+    onSelectedDatesChange(event: any): any;
+    openPicker(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatePickerDirective, "ui5-date-picker", ["ui5DatePicker"], { "formatPattern": "formatPattern"; "maxDate": "maxDate"; "minDate": "minDate"; "primaryCalendarType": "primaryCalendarType"; "secondaryCalendarType": "secondaryCalendarType"; "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "dateValue": "dateValue"; "disabled": "disabled"; "hideWeekNumbers": "hideWeekNumbers"; "name": "name"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "value": "value"; "valueState": "valueState"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+declare class DatePickerDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<DatePickerDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatePickerDirectiveCva, "ui5-date-picker", never, {}, {}, never, never, false, never>;
+}
+export { DatePickerDirective, DatePickerDirectiveCva, DatePickerDirectiveEventsMap, DatePickerDirectiveElement, };

package/main/directives/date-range-picker.d.ts

@@ -0,0 +1,127 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/DateRangePicker.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface DateRangePickerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<{
+        value: string;
+        valid: boolean;
+    }>;
+    input: CustomEvent<{
+        value: string;
+        valid: boolean;
+    }>;
+}
+interface DateRangePickerDirectiveElement extends Omit<HTMLElement, 'formatPattern' | 'maxDate' | 'minDate' | 'primaryCalendarType' | 'secondaryCalendarType' | 'accessibleName' | 'accessibleNameRef' | 'dateValue' | 'disabled' | 'hideWeekNumbers' | 'name' | 'placeholder' | 'readonly' | 'required' | 'value' | 'valueState' | 'dateValueUtc' | 'delimiter' | 'endDateValue' | 'startDateValue' | 'change' | 'input' | 'valueStateMessage'> {
+    formatPattern: string;
+    maxDate: string;
+    minDate: string;
+    primaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    secondaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    accessibleName: string;
+    accessibleNameRef: string;
+    dateValue: any;
+    disabled: boolean;
+    hideWeekNumbers: boolean;
+    name: string;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    dateValueUtc: any;
+    delimiter: string;
+    endDateValue: any;
+    startDateValue: any;
+    valueStateMessage: HTMLElement;
+    addEventListener<K extends keyof DateRangePickerDirectiveEventsMap>(type: K, listener: (this: DateRangePickerDirectiveElement, ev: DateRangePickerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof DateRangePickerDirectiveEventsMap>(type: K, listener: (this: DateRangePickerDirectiveElement, ev: DateRangePickerDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    _checkValueValidity(): any;
+    _modifyDateValue(amount: any, unit: any): any;
+    _onInputChange(): any;
+    _onInputInput(): any;
+    _onInputSubmit(): any;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isInValidRange(value: string): boolean;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    normalizeValue(): any;
+    onResponsivePopoverAfterClose(): any;
+    onSelectedDatesChange(event: any): any;
+    openPicker(): any;
+}
+declare class DateRangePickerDirective {
+    private elementRef;
+    set formatPattern(val: DateRangePickerDirectiveElement['formatPattern']);
+    get formatPattern(): DateRangePickerDirectiveElement['formatPattern'];
+    set maxDate(val: DateRangePickerDirectiveElement['maxDate']);
+    get maxDate(): DateRangePickerDirectiveElement['maxDate'];
+    set minDate(val: DateRangePickerDirectiveElement['minDate']);
+    get minDate(): DateRangePickerDirectiveElement['minDate'];
+    set primaryCalendarType(val: DateRangePickerDirectiveElement['primaryCalendarType']);
+    get primaryCalendarType(): DateRangePickerDirectiveElement['primaryCalendarType'];
+    set secondaryCalendarType(val: DateRangePickerDirectiveElement['secondaryCalendarType']);
+    get secondaryCalendarType(): DateRangePickerDirectiveElement['secondaryCalendarType'];
+    set accessibleName(val: DateRangePickerDirectiveElement['accessibleName']);
+    get accessibleName(): DateRangePickerDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: DateRangePickerDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): DateRangePickerDirectiveElement['accessibleNameRef'];
+    set dateValue(val: DateRangePickerDirectiveElement['dateValue']);
+    get dateValue(): DateRangePickerDirectiveElement['dateValue'];
+    set disabled(val: DateRangePickerDirectiveElement['disabled']);
+    get disabled(): DateRangePickerDirectiveElement['disabled'];
+    set hideWeekNumbers(val: DateRangePickerDirectiveElement['hideWeekNumbers']);
+    get hideWeekNumbers(): DateRangePickerDirectiveElement['hideWeekNumbers'];
+    set name(val: DateRangePickerDirectiveElement['name']);
+    get name(): DateRangePickerDirectiveElement['name'];
+    set placeholder(val: DateRangePickerDirectiveElement['placeholder']);
+    get placeholder(): DateRangePickerDirectiveElement['placeholder'];
+    set readonly(val: DateRangePickerDirectiveElement['readonly']);
+    get readonly(): DateRangePickerDirectiveElement['readonly'];
+    set required(val: DateRangePickerDirectiveElement['required']);
+    get required(): DateRangePickerDirectiveElement['required'];
+    set value(val: DateRangePickerDirectiveElement['value']);
+    get value(): DateRangePickerDirectiveElement['value'];
+    set valueState(val: DateRangePickerDirectiveElement['valueState']);
+    get valueState(): DateRangePickerDirectiveElement['valueState'];
+    set dateValueUtc(val: DateRangePickerDirectiveElement['dateValueUtc']);
+    get dateValueUtc(): DateRangePickerDirectiveElement['dateValueUtc'];
+    set delimiter(val: DateRangePickerDirectiveElement['delimiter']);
+    get delimiter(): DateRangePickerDirectiveElement['delimiter'];
+    set endDateValue(val: DateRangePickerDirectiveElement['endDateValue']);
+    get endDateValue(): DateRangePickerDirectiveElement['endDateValue'];
+    set startDateValue(val: DateRangePickerDirectiveElement['startDateValue']);
+    get startDateValue(): DateRangePickerDirectiveElement['startDateValue'];
+    change: Observable<DateRangePickerDirectiveEventsMap['change']>;
+    input: Observable<DateRangePickerDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<DateRangePickerDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): HTMLElement;
+    _checkValueValidity(): any;
+    _modifyDateValue(amount: any, unit: any): any;
+    _onInputChange(): any;
+    _onInputInput(): any;
+    _onInputSubmit(): any;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isInValidRange(value: string): boolean;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    normalizeValue(): any;
+    onResponsivePopoverAfterClose(): any;
+    onSelectedDatesChange(event: any): any;
+    openPicker(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateRangePickerDirective, "ui5-daterange-picker", ["ui5DaterangePicker"], { "formatPattern": "formatPattern"; "maxDate": "maxDate"; "minDate": "minDate"; "primaryCalendarType": "primaryCalendarType"; "secondaryCalendarType": "secondaryCalendarType"; "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "dateValue": "dateValue"; "disabled": "disabled"; "hideWeekNumbers": "hideWeekNumbers"; "name": "name"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "value": "value"; "valueState": "valueState"; "dateValueUtc": "dateValueUtc"; "delimiter": "delimiter"; "endDateValue": "endDateValue"; "startDateValue": "startDateValue"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+declare class DateRangePickerDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<DateRangePickerDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateRangePickerDirectiveCva, "ui5-daterange-picker", never, {}, {}, never, never, false, never>;
+}
+export { DateRangePickerDirective, DateRangePickerDirectiveCva, DateRangePickerDirectiveEventsMap, DateRangePickerDirectiveElement, };

package/main/directives/date-time-picker.d.ts

@@ -0,0 +1,115 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/DateTimePicker.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface DateTimePickerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<{
+        value: string;
+        valid: boolean;
+    }>;
+    input: CustomEvent<{
+        value: string;
+        valid: boolean;
+    }>;
+}
+interface DateTimePickerDirectiveElement extends Omit<HTMLElement, 'formatPattern' | 'maxDate' | 'minDate' | 'primaryCalendarType' | 'secondaryCalendarType' | 'accessibleName' | 'accessibleNameRef' | 'dateValue' | 'disabled' | 'hideWeekNumbers' | 'name' | 'placeholder' | 'readonly' | 'required' | 'value' | 'valueState' | 'change' | 'input' | 'valueStateMessage'> {
+    formatPattern: string;
+    maxDate: string;
+    minDate: string;
+    primaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    secondaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    accessibleName: string;
+    accessibleNameRef: string;
+    dateValue: any;
+    disabled: boolean;
+    hideWeekNumbers: boolean;
+    name: string;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    valueStateMessage: HTMLElement;
+    addEventListener<K extends keyof DateTimePickerDirectiveEventsMap>(type: K, listener: (this: DateTimePickerDirectiveElement, ev: DateTimePickerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof DateTimePickerDirectiveEventsMap>(type: K, listener: (this: DateTimePickerDirectiveElement, ev: DateTimePickerDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    _checkValueValidity(): any;
+    _modifyDateValue(amount: any, unit: any): any;
+    _onInputChange(): any;
+    _onInputInput(): any;
+    _onInputSubmit(): any;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isInValidRange(value: string): boolean;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    normalizeValue(): any;
+    onResponsivePopoverAfterClose(): any;
+    onSelectedDatesChange(event: any): any;
+    openPicker(): any;
+}
+declare class DateTimePickerDirective {
+    private elementRef;
+    set formatPattern(val: DateTimePickerDirectiveElement['formatPattern']);
+    get formatPattern(): DateTimePickerDirectiveElement['formatPattern'];
+    set maxDate(val: DateTimePickerDirectiveElement['maxDate']);
+    get maxDate(): DateTimePickerDirectiveElement['maxDate'];
+    set minDate(val: DateTimePickerDirectiveElement['minDate']);
+    get minDate(): DateTimePickerDirectiveElement['minDate'];
+    set primaryCalendarType(val: DateTimePickerDirectiveElement['primaryCalendarType']);
+    get primaryCalendarType(): DateTimePickerDirectiveElement['primaryCalendarType'];
+    set secondaryCalendarType(val: DateTimePickerDirectiveElement['secondaryCalendarType']);
+    get secondaryCalendarType(): DateTimePickerDirectiveElement['secondaryCalendarType'];
+    set accessibleName(val: DateTimePickerDirectiveElement['accessibleName']);
+    get accessibleName(): DateTimePickerDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: DateTimePickerDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): DateTimePickerDirectiveElement['accessibleNameRef'];
+    set dateValue(val: DateTimePickerDirectiveElement['dateValue']);
+    get dateValue(): DateTimePickerDirectiveElement['dateValue'];
+    set disabled(val: DateTimePickerDirectiveElement['disabled']);
+    get disabled(): DateTimePickerDirectiveElement['disabled'];
+    set hideWeekNumbers(val: DateTimePickerDirectiveElement['hideWeekNumbers']);
+    get hideWeekNumbers(): DateTimePickerDirectiveElement['hideWeekNumbers'];
+    set name(val: DateTimePickerDirectiveElement['name']);
+    get name(): DateTimePickerDirectiveElement['name'];
+    set placeholder(val: DateTimePickerDirectiveElement['placeholder']);
+    get placeholder(): DateTimePickerDirectiveElement['placeholder'];
+    set readonly(val: DateTimePickerDirectiveElement['readonly']);
+    get readonly(): DateTimePickerDirectiveElement['readonly'];
+    set required(val: DateTimePickerDirectiveElement['required']);
+    get required(): DateTimePickerDirectiveElement['required'];
+    set value(val: DateTimePickerDirectiveElement['value']);
+    get value(): DateTimePickerDirectiveElement['value'];
+    set valueState(val: DateTimePickerDirectiveElement['valueState']);
+    get valueState(): DateTimePickerDirectiveElement['valueState'];
+    change: Observable<DateTimePickerDirectiveEventsMap['change']>;
+    input: Observable<DateTimePickerDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<DateTimePickerDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): HTMLElement;
+    _checkValueValidity(): any;
+    _modifyDateValue(amount: any, unit: any): any;
+    _onInputChange(): any;
+    _onInputInput(): any;
+    _onInputSubmit(): any;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isInValidRange(value: string): boolean;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    normalizeValue(): any;
+    onResponsivePopoverAfterClose(): any;
+    onSelectedDatesChange(event: any): any;
+    openPicker(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimePickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateTimePickerDirective, "ui5-datetime-picker", ["ui5DatetimePicker"], { "formatPattern": "formatPattern"; "maxDate": "maxDate"; "minDate": "minDate"; "primaryCalendarType": "primaryCalendarType"; "secondaryCalendarType": "secondaryCalendarType"; "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "dateValue": "dateValue"; "disabled": "disabled"; "hideWeekNumbers": "hideWeekNumbers"; "name": "name"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "value": "value"; "valueState": "valueState"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+declare class DateTimePickerDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<DateTimePickerDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimePickerDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateTimePickerDirectiveCva, "ui5-datetime-picker", never, {}, {}, never, never, false, never>;
+}
+export { DateTimePickerDirective, DateTimePickerDirectiveCva, DateTimePickerDirectiveEventsMap, DateTimePickerDirectiveElement, };