@ui5/webcomponents-ngx 0.0.1-rc.0

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

@@ -0,0 +1,60 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/DayPicker.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface DayPickerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'navigate'> {
+    change: CustomEvent<void>;
+    navigate: CustomEvent<void>;
+}
+interface DayPickerDirectiveElement extends Omit<HTMLElement, 'formatPattern' | 'maxDate' | 'minDate' | 'primaryCalendarType' | 'secondaryCalendarType' | 'hideWeekNumbers' | 'selectedDates' | 'selectionMode' | 'change' | 'navigate'> {
+    formatPattern: string;
+    maxDate: string;
+    minDate: string;
+    primaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    secondaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    hideWeekNumbers: boolean;
+    selectedDates: Array<any>;
+    selectionMode: 'Multiple' | 'Range' | 'Single';
+    addEventListener<K extends keyof DayPickerDirectiveEventsMap>(type: K, listener: (this: DayPickerDirectiveElement, ev: DayPickerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof DayPickerDirectiveEventsMap>(type: K, listener: (this: DayPickerDirectiveElement, ev: DayPickerDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    _safelyModifyTimestampBy(amount: any, unit: any): any;
+    _safelySetTimestamp(timestamp: any): any;
+    _hasNextPage(): any;
+    _hasPreviousPage(): any;
+    _showNextPage(): any;
+    _showPreviousPage(): any;
+}
+declare class DayPickerDirective {
+    private elementRef;
+    set formatPattern(val: DayPickerDirectiveElement['formatPattern']);
+    get formatPattern(): DayPickerDirectiveElement['formatPattern'];
+    set maxDate(val: DayPickerDirectiveElement['maxDate']);
+    get maxDate(): DayPickerDirectiveElement['maxDate'];
+    set minDate(val: DayPickerDirectiveElement['minDate']);
+    get minDate(): DayPickerDirectiveElement['minDate'];
+    set primaryCalendarType(val: DayPickerDirectiveElement['primaryCalendarType']);
+    get primaryCalendarType(): DayPickerDirectiveElement['primaryCalendarType'];
+    set secondaryCalendarType(val: DayPickerDirectiveElement['secondaryCalendarType']);
+    get secondaryCalendarType(): DayPickerDirectiveElement['secondaryCalendarType'];
+    set hideWeekNumbers(val: DayPickerDirectiveElement['hideWeekNumbers']);
+    get hideWeekNumbers(): DayPickerDirectiveElement['hideWeekNumbers'];
+    set selectedDates(val: DayPickerDirectiveElement['selectedDates']);
+    get selectedDates(): DayPickerDirectiveElement['selectedDates'];
+    set selectionMode(val: DayPickerDirectiveElement['selectionMode']);
+    get selectionMode(): DayPickerDirectiveElement['selectionMode'];
+    change: Observable<DayPickerDirectiveEventsMap['change']>;
+    navigate: Observable<DayPickerDirectiveEventsMap['navigate']>;
+    constructor(elementRef: ElementRef<DayPickerDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    _safelyModifyTimestampBy(amount: any, unit: any): any;
+    _safelySetTimestamp(timestamp: any): any;
+    _hasNextPage(): any;
+    _hasPreviousPage(): any;
+    _showNextPage(): any;
+    _showPreviousPage(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DayPickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DayPickerDirective, "ui5-daypicker", ["ui5Daypicker"], { "formatPattern": "formatPattern"; "maxDate": "maxDate"; "minDate": "minDate"; "primaryCalendarType": "primaryCalendarType"; "secondaryCalendarType": "secondaryCalendarType"; "hideWeekNumbers": "hideWeekNumbers"; "selectedDates": "selectedDates"; "selectionMode": "selectionMode"; }, { "change": "change"; "navigate": "navigate"; }, never, never, false, never>;
+}
+export { DayPickerDirective, DayPickerDirectiveEventsMap, DayPickerDirectiveElement, };

package/main/directives/dialog.d.ts

@@ -0,0 +1,90 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Dialog.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface DialogDirectiveEventsMap extends Omit<HTMLElementEventMap, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen'> {
+    afterClose: CustomEvent<void>;
+    afterOpen: CustomEvent<void>;
+    beforeClose: CustomEvent<{
+        escPressed: boolean;
+    }>;
+    beforeOpen: CustomEvent<void>;
+}
+interface DialogDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'initialFocus' | 'open' | 'preventFocusRestore' | 'draggable' | 'headerText' | 'resizable' | 'state' | 'stretch' | 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen' | 'footer' | 'header'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    initialFocus: string;
+    open: boolean;
+    preventFocusRestore: boolean;
+    draggable: boolean;
+    headerText: string;
+    resizable: boolean;
+    state: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    stretch: boolean;
+    footer: Array<HTMLElement>;
+    header: Array<HTMLElement>;
+    addEventListener<K extends keyof DialogDirectiveEventsMap>(type: K, listener: (this: DialogDirectiveElement, ev: DialogDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof DialogDirectiveEventsMap>(type: K, listener: (this: DialogDirectiveElement, ev: DialogDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    _addOpenedPopup(): any;
+    _open(): any;
+    _removeOpenedPopup(): any;
+    _show(): any;
+    applyFocus(): any;
+    applyInitialFocus(): any;
+    blockPageScrolling(): any;
+    close(): any;
+    hide(): any;
+    isOpen(): boolean;
+    resetFocus(): any;
+    unblockPageScrolling(): any;
+    show(preventInitialFocus: boolean): any;
+}
+declare class DialogDirective {
+    private elementRef;
+    set accessibleName(val: DialogDirectiveElement['accessibleName']);
+    get accessibleName(): DialogDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: DialogDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): DialogDirectiveElement['accessibleNameRef'];
+    set initialFocus(val: DialogDirectiveElement['initialFocus']);
+    get initialFocus(): DialogDirectiveElement['initialFocus'];
+    set open(val: DialogDirectiveElement['open']);
+    get open(): DialogDirectiveElement['open'];
+    set preventFocusRestore(val: DialogDirectiveElement['preventFocusRestore']);
+    get preventFocusRestore(): DialogDirectiveElement['preventFocusRestore'];
+    set draggable(val: DialogDirectiveElement['draggable']);
+    get draggable(): DialogDirectiveElement['draggable'];
+    set headerText(val: DialogDirectiveElement['headerText']);
+    get headerText(): DialogDirectiveElement['headerText'];
+    set resizable(val: DialogDirectiveElement['resizable']);
+    get resizable(): DialogDirectiveElement['resizable'];
+    set state(val: DialogDirectiveElement['state']);
+    get state(): DialogDirectiveElement['state'];
+    set stretch(val: DialogDirectiveElement['stretch']);
+    get stretch(): DialogDirectiveElement['stretch'];
+    afterClose: Observable<DialogDirectiveEventsMap['afterClose']>;
+    afterOpen: Observable<DialogDirectiveEventsMap['afterOpen']>;
+    beforeClose: Observable<DialogDirectiveEventsMap['beforeClose']>;
+    beforeOpen: Observable<DialogDirectiveEventsMap['beforeOpen']>;
+    constructor(elementRef: ElementRef<DialogDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get footer(): Array<HTMLElement>;
+    get header(): Array<HTMLElement>;
+    _addOpenedPopup(): any;
+    _open(): any;
+    _removeOpenedPopup(): any;
+    _show(): any;
+    applyFocus(): any;
+    applyInitialFocus(): any;
+    blockPageScrolling(): any;
+    close(): any;
+    hide(): any;
+    isOpen(): boolean;
+    resetFocus(): any;
+    unblockPageScrolling(): any;
+    show(preventInitialFocus: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogDirective, "ui5-dialog", ["ui5Dialog"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "initialFocus": "initialFocus"; "open": "open"; "preventFocusRestore": "preventFocusRestore"; "draggable": "draggable"; "headerText": "headerText"; "resizable": "resizable"; "state": "state"; "stretch": "stretch"; }, { "afterClose": "afterClose"; "afterOpen": "afterOpen"; "beforeClose": "beforeClose"; "beforeOpen": "beforeOpen"; }, never, never, false, never>;
+}
+export { DialogDirective, DialogDirectiveEventsMap, DialogDirectiveElement };

package/main/directives/file-uploader.d.ts

@@ -0,0 +1,60 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/FileUploader.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface FileUploaderDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<{
+        files: any;
+    }>;
+}
+interface FileUploaderDirectiveElement extends Omit<HTMLElement, 'accept' | 'disabled' | 'files' | 'hideInput' | 'multiple' | 'name' | 'placeholder' | 'value' | 'valueState' | 'change' | 'valueStateMessage'> {
+    accept: string;
+    disabled: boolean;
+    files: any;
+    hideInput: boolean;
+    multiple: boolean;
+    name: string;
+    placeholder: string;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    valueStateMessage: Array<HTMLElement>;
+    addEventListener<K extends keyof FileUploaderDirectiveEventsMap>(type: K, listener: (this: FileUploaderDirectiveElement, ev: FileUploaderDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof FileUploaderDirectiveEventsMap>(type: K, listener: (this: FileUploaderDirectiveElement, ev: FileUploaderDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class FileUploaderDirective {
+    private elementRef;
+    set accept(val: FileUploaderDirectiveElement['accept']);
+    get accept(): FileUploaderDirectiveElement['accept'];
+    set disabled(val: FileUploaderDirectiveElement['disabled']);
+    get disabled(): FileUploaderDirectiveElement['disabled'];
+    set files(val: FileUploaderDirectiveElement['files']);
+    get files(): FileUploaderDirectiveElement['files'];
+    set hideInput(val: FileUploaderDirectiveElement['hideInput']);
+    get hideInput(): FileUploaderDirectiveElement['hideInput'];
+    set multiple(val: FileUploaderDirectiveElement['multiple']);
+    get multiple(): FileUploaderDirectiveElement['multiple'];
+    set name(val: FileUploaderDirectiveElement['name']);
+    get name(): FileUploaderDirectiveElement['name'];
+    set placeholder(val: FileUploaderDirectiveElement['placeholder']);
+    get placeholder(): FileUploaderDirectiveElement['placeholder'];
+    set value(val: FileUploaderDirectiveElement['value']);
+    get value(): FileUploaderDirectiveElement['value'];
+    set valueState(val: FileUploaderDirectiveElement['valueState']);
+    get valueState(): FileUploaderDirectiveElement['valueState'];
+    change: Observable<FileUploaderDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<FileUploaderDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileUploaderDirective, "ui5-file-uploader", ["ui5FileUploader"], { "accept": "accept"; "disabled": "disabled"; "files": "files"; "hideInput": "hideInput"; "multiple": "multiple"; "name": "name"; "placeholder": "placeholder"; "value": "value"; "valueState": "valueState"; }, { "change": "change"; }, never, never, false, never>;
+}
+declare class FileUploaderDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<FileUploaderDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploaderDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileUploaderDirectiveCva, "ui5-file-uploader", never, {}, {}, never, never, false, never>;
+}
+export { FileUploaderDirective, FileUploaderDirectiveCva, FileUploaderDirectiveEventsMap, FileUploaderDirectiveElement, };

package/main/directives/group-header-list-item.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/GroupHeaderListItem.js';
+import * as i0 from "@angular/core";
+interface GroupHeaderListItemDirectiveElement extends Omit<HTMLElement, 'selected' | 'accessibleName'> {
+    selected: boolean;
+    accessibleName: string;
+}
+declare class GroupHeaderListItemDirective {
+    private elementRef;
+    set selected(val: GroupHeaderListItemDirectiveElement['selected']);
+    get selected(): GroupHeaderListItemDirectiveElement['selected'];
+    set accessibleName(val: GroupHeaderListItemDirectiveElement['accessibleName']);
+    get accessibleName(): GroupHeaderListItemDirectiveElement['accessibleName'];
+    constructor(elementRef: ElementRef<GroupHeaderListItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupHeaderListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GroupHeaderListItemDirective, "ui5-li-groupheader", ["ui5LiGroupheader"], { "selected": "selected"; "accessibleName": "accessibleName"; }, {}, never, never, false, never>;
+}
+export { GroupHeaderListItemDirective, GroupHeaderListItemDirectiveElement };

package/main/directives/icon.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Icon.js';
+import * as i0 from "@angular/core";
+interface IconDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleRole' | 'interactive' | 'name' | 'showTooltip'> {
+    accessibleName: string;
+    accessibleRole: string;
+    interactive: boolean;
+    name: string;
+    showTooltip: boolean;
+}
+declare class IconDirective {
+    private elementRef;
+    set accessibleName(val: IconDirectiveElement['accessibleName']);
+    get accessibleName(): IconDirectiveElement['accessibleName'];
+    set accessibleRole(val: IconDirectiveElement['accessibleRole']);
+    get accessibleRole(): IconDirectiveElement['accessibleRole'];
+    set interactive(val: IconDirectiveElement['interactive']);
+    get interactive(): IconDirectiveElement['interactive'];
+    set name(val: IconDirectiveElement['name']);
+    get name(): IconDirectiveElement['name'];
+    set showTooltip(val: IconDirectiveElement['showTooltip']);
+    get showTooltip(): IconDirectiveElement['showTooltip'];
+    constructor(elementRef: ElementRef<IconDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IconDirective, "ui5-icon", ["ui5Icon"], { "accessibleName": "accessibleName"; "accessibleRole": "accessibleRole"; "interactive": "interactive"; "name": "name"; "showTooltip": "showTooltip"; }, {}, never, never, false, never>;
+}
+export { IconDirective, IconDirectiveElement };

package/main/directives/input.d.ts

@@ -0,0 +1,98 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Input.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import { SuggestionGroupItemDirective } from './suggestion-group-item';
+import { SuggestionItemDirective } from './suggestion-item';
+import { IconDirective } from './icon';
+import * as i0 from "@angular/core";
+interface InputDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input' | 'suggestionItemPreview' | 'suggestionItemSelect'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+    suggestionItemPreview: CustomEvent<{
+        item: HTMLElement;
+        targetRef: HTMLElement;
+    }>;
+    suggestionItemSelect: CustomEvent<{
+        item: HTMLElement;
+    }>;
+}
+interface InputDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'maxlength' | 'name' | 'noTypeahead' | 'placeholder' | 'previewItem' | 'readonly' | 'required' | 'showClearIcon' | 'showSuggestions' | 'type' | 'value' | 'valueState' | 'change' | 'input' | 'suggestionItemPreview' | 'suggestionItemSelect' | 'icon' | 'valueStateMessage'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    disabled: boolean;
+    maxlength: any;
+    name: string;
+    noTypeahead: boolean;
+    placeholder: string;
+    previewItem: SuggestionGroupItemDirective['element'] | SuggestionItemDirective['element'];
+    readonly: boolean;
+    required: boolean;
+    showClearIcon: boolean;
+    showSuggestions: boolean;
+    type: 'Email' | 'Number' | 'Password' | 'Tel' | 'Text' | 'URL';
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    icon: Array<IconDirective['element']>;
+    valueStateMessage: Array<HTMLElement>;
+    addEventListener<K extends keyof InputDirectiveEventsMap>(type: K, listener: (this: InputDirectiveElement, ev: InputDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof InputDirectiveEventsMap>(type: K, listener: (this: InputDirectiveElement, ev: InputDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    getCaretPosition(): any;
+    openPicker(): any;
+    setCaretPosition(pos: any): any;
+}
+declare class InputDirective {
+    private elementRef;
+    set accessibleName(val: InputDirectiveElement['accessibleName']);
+    get accessibleName(): InputDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: InputDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): InputDirectiveElement['accessibleNameRef'];
+    set disabled(val: InputDirectiveElement['disabled']);
+    get disabled(): InputDirectiveElement['disabled'];
+    set maxlength(val: InputDirectiveElement['maxlength']);
+    get maxlength(): InputDirectiveElement['maxlength'];
+    set name(val: InputDirectiveElement['name']);
+    get name(): InputDirectiveElement['name'];
+    set noTypeahead(val: InputDirectiveElement['noTypeahead']);
+    get noTypeahead(): InputDirectiveElement['noTypeahead'];
+    set placeholder(val: InputDirectiveElement['placeholder']);
+    get placeholder(): InputDirectiveElement['placeholder'];
+    set previewItem(val: InputDirectiveElement['previewItem']);
+    get previewItem(): InputDirectiveElement['previewItem'];
+    set readonly(val: InputDirectiveElement['readonly']);
+    get readonly(): InputDirectiveElement['readonly'];
+    set required(val: InputDirectiveElement['required']);
+    get required(): InputDirectiveElement['required'];
+    set showClearIcon(val: InputDirectiveElement['showClearIcon']);
+    get showClearIcon(): InputDirectiveElement['showClearIcon'];
+    set showSuggestions(val: InputDirectiveElement['showSuggestions']);
+    get showSuggestions(): InputDirectiveElement['showSuggestions'];
+    set type(val: InputDirectiveElement['type']);
+    get type(): InputDirectiveElement['type'];
+    set value(val: InputDirectiveElement['value']);
+    get value(): InputDirectiveElement['value'];
+    set valueState(val: InputDirectiveElement['valueState']);
+    get valueState(): InputDirectiveElement['valueState'];
+    change: Observable<InputDirectiveEventsMap['change']>;
+    input: Observable<InputDirectiveEventsMap['input']>;
+    suggestionItemPreview: Observable<InputDirectiveEventsMap['suggestionItemPreview']>;
+    suggestionItemSelect: Observable<InputDirectiveEventsMap['suggestionItemSelect']>;
+    constructor(elementRef: ElementRef<InputDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get icon(): Array<IconDirective['element']>;
+    get valueStateMessage(): Array<HTMLElement>;
+    getCaretPosition(): any;
+    openPicker(): any;
+    setCaretPosition(pos: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirective, "ui5-input", ["ui5Input"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "disabled": "disabled"; "maxlength": "maxlength"; "name": "name"; "noTypeahead": "noTypeahead"; "placeholder": "placeholder"; "previewItem": "previewItem"; "readonly": "readonly"; "required": "required"; "showClearIcon": "showClearIcon"; "showSuggestions": "showSuggestions"; "type": "type"; "value": "value"; "valueState": "valueState"; }, { "change": "change"; "input": "input"; "suggestionItemPreview": "suggestionItemPreview"; "suggestionItemSelect": "suggestionItemSelect"; }, never, never, false, never>;
+}
+declare class InputDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<InputDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirectiveCva, "ui5-input", never, {}, {}, never, never, false, never>;
+}
+export { InputDirective, InputDirectiveCva, InputDirectiveEventsMap, InputDirectiveElement, };

package/main/directives/label.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Label.js';
+import * as i0 from "@angular/core";
+interface LabelDirectiveElement extends Omit<HTMLElement, 'for' | 'required' | 'showColon' | 'wrappingType'> {
+    for: string;
+    required: boolean;
+    showColon: boolean;
+    wrappingType: 'None' | 'Normal';
+}
+declare class LabelDirective {
+    private elementRef;
+    set for(val: LabelDirectiveElement['for']);
+    get for(): LabelDirectiveElement['for'];
+    set required(val: LabelDirectiveElement['required']);
+    get required(): LabelDirectiveElement['required'];
+    set showColon(val: LabelDirectiveElement['showColon']);
+    get showColon(): LabelDirectiveElement['showColon'];
+    set wrappingType(val: LabelDirectiveElement['wrappingType']);
+    get wrappingType(): LabelDirectiveElement['wrappingType'];
+    constructor(elementRef: ElementRef<LabelDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LabelDirective, "ui5-label", ["ui5Label"], { "for": "for"; "required": "required"; "showColon": "showColon"; "wrappingType": "wrappingType"; }, {}, never, never, false, never>;
+}
+export { LabelDirective, LabelDirectiveElement };

package/main/directives/link.d.ts

@@ -0,0 +1,57 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Link.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface LinkDirectiveEventsMap extends Omit<HTMLElementEventMap, 'click'> {
+    click: CustomEvent<{
+        altKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        shiftKey: boolean;
+    }>;
+}
+interface LinkDirectiveElement extends Omit<HTMLElement, 'accessibilityAttributes' | 'accessibleName' | 'accessibleNameRef' | 'accessibleRole' | 'design' | 'disabled' | 'href' | 'target' | 'wrappingType' | 'click'> {
+    accessibilityAttributes: {
+        expanded?: boolean;
+        hasPopup?: 'Dialog' | 'Grid' | 'Listbox' | 'Menu' | 'Tree';
+    };
+    accessibleName: string;
+    accessibleNameRef: string;
+    accessibleRole: string;
+    design: 'Default' | 'Emphasized' | 'Subtle';
+    disabled: boolean;
+    href: string;
+    target: string;
+    wrappingType: 'None' | 'Normal';
+    addEventListener<K extends keyof LinkDirectiveEventsMap>(type: K, listener: (this: LinkDirectiveElement, ev: LinkDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof LinkDirectiveEventsMap>(type: K, listener: (this: LinkDirectiveElement, ev: LinkDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class LinkDirective {
+    private elementRef;
+    set accessibilityAttributes(val: LinkDirectiveElement['accessibilityAttributes']);
+    get accessibilityAttributes(): LinkDirectiveElement['accessibilityAttributes'];
+    set accessibleName(val: LinkDirectiveElement['accessibleName']);
+    get accessibleName(): LinkDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: LinkDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): LinkDirectiveElement['accessibleNameRef'];
+    set accessibleRole(val: LinkDirectiveElement['accessibleRole']);
+    get accessibleRole(): LinkDirectiveElement['accessibleRole'];
+    set design(val: LinkDirectiveElement['design']);
+    get design(): LinkDirectiveElement['design'];
+    set disabled(val: LinkDirectiveElement['disabled']);
+    get disabled(): LinkDirectiveElement['disabled'];
+    set href(val: LinkDirectiveElement['href']);
+    get href(): LinkDirectiveElement['href'];
+    set target(val: LinkDirectiveElement['target']);
+    get target(): LinkDirectiveElement['target'];
+    set wrappingType(val: LinkDirectiveElement['wrappingType']);
+    get wrappingType(): LinkDirectiveElement['wrappingType'];
+    click: Observable<LinkDirectiveEventsMap['click']>;
+    constructor(elementRef: ElementRef<LinkDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LinkDirective, "ui5-link", ["ui5Link"], { "accessibilityAttributes": "accessibilityAttributes"; "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "accessibleRole": "accessibleRole"; "design": "design"; "disabled": "disabled"; "href": "href"; "target": "target"; "wrappingType": "wrappingType"; }, { "click": "click"; }, never, never, false, never>;
+}
+export { LinkDirective, LinkDirectiveEventsMap, LinkDirectiveElement };

package/main/directives/list.d.ts

@@ -0,0 +1,85 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/List.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ListDirectiveEventsMap extends Omit<HTMLElementEventMap, 'itemClick' | 'itemClose' | 'itemDelete' | 'itemToggle' | 'loadMore' | 'selectionChange'> {
+    itemClick: CustomEvent<{
+        item: HTMLElement;
+    }>;
+    itemClose: CustomEvent<{
+        item: HTMLElement;
+    }>;
+    itemDelete: CustomEvent<{
+        item: HTMLElement;
+    }>;
+    itemToggle: CustomEvent<{
+        item: HTMLElement;
+    }>;
+    loadMore: CustomEvent<void>;
+    selectionChange: CustomEvent<{
+        selectedItems: Array<any>;
+        previouslySelectedItems: Array<any>;
+    }>;
+}
+interface ListDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'accessibleRole' | 'busy' | 'busyDelay' | 'footerText' | 'growing' | 'headerText' | 'indent' | 'mode' | 'noDataText' | 'separators' | 'itemClick' | 'itemClose' | 'itemDelete' | 'itemToggle' | 'loadMore' | 'selectionChange' | 'header'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    accessibleRole: string;
+    busy: boolean;
+    busyDelay: any;
+    footerText: string;
+    growing: 'Button' | 'None' | 'Scroll';
+    headerText: string;
+    indent: boolean;
+    mode: 'Delete' | 'MultiSelect' | 'None' | 'SingleSelect' | 'SingleSelectAuto' | 'SingleSelectBegin' | 'SingleSelectEnd';
+    noDataText: string;
+    separators: 'All' | 'Inner' | 'None';
+    header: Array<HTMLElement>;
+    addEventListener<K extends keyof ListDirectiveEventsMap>(type: K, listener: (this: ListDirectiveElement, ev: ListDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ListDirectiveEventsMap>(type: K, listener: (this: ListDirectiveElement, ev: ListDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    focusFirstItem(): any;
+    focusItem(item: any): any;
+}
+declare class ListDirective {
+    private elementRef;
+    set accessibleName(val: ListDirectiveElement['accessibleName']);
+    get accessibleName(): ListDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: ListDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): ListDirectiveElement['accessibleNameRef'];
+    set accessibleRole(val: ListDirectiveElement['accessibleRole']);
+    get accessibleRole(): ListDirectiveElement['accessibleRole'];
+    set busy(val: ListDirectiveElement['busy']);
+    get busy(): ListDirectiveElement['busy'];
+    set busyDelay(val: ListDirectiveElement['busyDelay']);
+    get busyDelay(): ListDirectiveElement['busyDelay'];
+    set footerText(val: ListDirectiveElement['footerText']);
+    get footerText(): ListDirectiveElement['footerText'];
+    set growing(val: ListDirectiveElement['growing']);
+    get growing(): ListDirectiveElement['growing'];
+    set headerText(val: ListDirectiveElement['headerText']);
+    get headerText(): ListDirectiveElement['headerText'];
+    set indent(val: ListDirectiveElement['indent']);
+    get indent(): ListDirectiveElement['indent'];
+    set mode(val: ListDirectiveElement['mode']);
+    get mode(): ListDirectiveElement['mode'];
+    set noDataText(val: ListDirectiveElement['noDataText']);
+    get noDataText(): ListDirectiveElement['noDataText'];
+    set separators(val: ListDirectiveElement['separators']);
+    get separators(): ListDirectiveElement['separators'];
+    itemClick: Observable<ListDirectiveEventsMap['itemClick']>;
+    itemClose: Observable<ListDirectiveEventsMap['itemClose']>;
+    itemDelete: Observable<ListDirectiveEventsMap['itemDelete']>;
+    itemToggle: Observable<ListDirectiveEventsMap['itemToggle']>;
+    loadMore: Observable<ListDirectiveEventsMap['loadMore']>;
+    selectionChange: Observable<ListDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<ListDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get header(): Array<HTMLElement>;
+    focusFirstItem(): any;
+    focusItem(item: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ListDirective, "ui5-list", ["ui5List"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "accessibleRole": "accessibleRole"; "busy": "busy"; "busyDelay": "busyDelay"; "footerText": "footerText"; "growing": "growing"; "headerText": "headerText"; "indent": "indent"; "mode": "mode"; "noDataText": "noDataText"; "separators": "separators"; }, { "itemClick": "itemClick"; "itemClose": "itemClose"; "itemDelete": "itemDelete"; "itemToggle": "itemToggle"; "loadMore": "loadMore"; "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+export { ListDirective, ListDirectiveEventsMap, ListDirectiveElement };

package/main/directives/menu-item.d.ts

@@ -0,0 +1,31 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/MenuItem.js';
+import * as i0 from "@angular/core";
+interface MenuItemDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'additionalText' | 'disabled' | 'icon' | 'startsSection' | 'text'> {
+    accessibleName: string;
+    additionalText: string;
+    disabled: boolean;
+    icon: string;
+    startsSection: boolean;
+    text: string;
+}
+declare class MenuItemDirective {
+    private elementRef;
+    set accessibleName(val: MenuItemDirectiveElement['accessibleName']);
+    get accessibleName(): MenuItemDirectiveElement['accessibleName'];
+    set additionalText(val: MenuItemDirectiveElement['additionalText']);
+    get additionalText(): MenuItemDirectiveElement['additionalText'];
+    set disabled(val: MenuItemDirectiveElement['disabled']);
+    get disabled(): MenuItemDirectiveElement['disabled'];
+    set icon(val: MenuItemDirectiveElement['icon']);
+    get icon(): MenuItemDirectiveElement['icon'];
+    set startsSection(val: MenuItemDirectiveElement['startsSection']);
+    get startsSection(): MenuItemDirectiveElement['startsSection'];
+    set text(val: MenuItemDirectiveElement['text']);
+    get text(): MenuItemDirectiveElement['text'];
+    constructor(elementRef: ElementRef<MenuItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuItemDirective, "ui5-menu-item", ["ui5MenuItem"], { "accessibleName": "accessibleName"; "additionalText": "additionalText"; "disabled": "disabled"; "icon": "icon"; "startsSection": "startsSection"; "text": "text"; }, {}, never, never, false, never>;
+}
+export { MenuItemDirective, MenuItemDirectiveElement };

package/main/directives/menu.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Menu.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface MenuDirectiveEventsMap extends Omit<HTMLElementEventMap, 'itemClick'> {
+    itemClick: CustomEvent<{
+        item: Record<string, any>;
+        text: string;
+    }>;
+}
+interface MenuDirectiveElement extends Omit<HTMLElement, 'headerText' | 'itemClick'> {
+    headerText: string;
+    addEventListener<K extends keyof MenuDirectiveEventsMap>(type: K, listener: (this: MenuDirectiveElement, ev: MenuDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MenuDirectiveEventsMap>(type: K, listener: (this: MenuDirectiveElement, ev: MenuDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    close(): any;
+    showAt(opener: HTMLElement): any;
+}
+declare class MenuDirective {
+    private elementRef;
+    set headerText(val: MenuDirectiveElement['headerText']);
+    get headerText(): MenuDirectiveElement['headerText'];
+    itemClick: Observable<MenuDirectiveEventsMap['itemClick']>;
+    constructor(elementRef: ElementRef<MenuDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    close(): any;
+    showAt(opener: HTMLElement): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuDirective, "ui5-menu", ["ui5Menu"], { "headerText": "headerText"; }, { "itemClick": "itemClick"; }, never, never, false, never>;
+}
+export { MenuDirective, MenuDirectiveEventsMap, MenuDirectiveElement };

package/main/directives/message-strip.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/MessageStrip.js';
+import { Observable } from 'rxjs';
+import { IconDirective } from './icon';
+import * as i0 from "@angular/core";
+interface MessageStripDirectiveEventsMap extends Omit<HTMLElementEventMap, 'close'> {
+    close: CustomEvent<void>;
+}
+interface MessageStripDirectiveElement extends Omit<HTMLElement, 'design' | 'hideCloseButton' | 'hideIcon' | 'close' | 'icon'> {
+    design: 'Information' | 'Negative' | 'Positive' | 'Warning';
+    hideCloseButton: boolean;
+    hideIcon: boolean;
+    icon: IconDirective['element'];
+    addEventListener<K extends keyof MessageStripDirectiveEventsMap>(type: K, listener: (this: MessageStripDirectiveElement, ev: MessageStripDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MessageStripDirectiveEventsMap>(type: K, listener: (this: MessageStripDirectiveElement, ev: MessageStripDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class MessageStripDirective {
+    private elementRef;
+    set design(val: MessageStripDirectiveElement['design']);
+    get design(): MessageStripDirectiveElement['design'];
+    set hideCloseButton(val: MessageStripDirectiveElement['hideCloseButton']);
+    get hideCloseButton(): MessageStripDirectiveElement['hideCloseButton'];
+    set hideIcon(val: MessageStripDirectiveElement['hideIcon']);
+    get hideIcon(): MessageStripDirectiveElement['hideIcon'];
+    close: Observable<MessageStripDirectiveEventsMap['close']>;
+    constructor(elementRef: ElementRef<MessageStripDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get icon(): IconDirective['element'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageStripDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MessageStripDirective, "ui5-message-strip", ["ui5MessageStrip"], { "design": "design"; "hideCloseButton": "hideCloseButton"; "hideIcon": "hideIcon"; }, { "close": "close"; }, never, never, false, never>;
+}
+export { MessageStripDirective, MessageStripDirectiveEventsMap, MessageStripDirectiveElement, };