@ui5/webcomponents-ngx 0.0.1-rc.0

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

@@ -0,0 +1,54 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/MonthPicker.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface MonthPickerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'navigate'> {
+    change: CustomEvent<void>;
+    navigate: CustomEvent<void>;
+}
+interface MonthPickerDirectiveElement extends Omit<HTMLElement, 'formatPattern' | 'maxDate' | 'minDate' | 'primaryCalendarType' | 'secondaryCalendarType' | 'selectedDates' | 'change' | 'navigate'> {
+    formatPattern: string;
+    maxDate: string;
+    minDate: string;
+    primaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    secondaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    selectedDates: Array<any>;
+    addEventListener<K extends keyof MonthPickerDirectiveEventsMap>(type: K, listener: (this: MonthPickerDirectiveElement, ev: MonthPickerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MonthPickerDirectiveEventsMap>(type: K, listener: (this: MonthPickerDirectiveElement, ev: MonthPickerDirectiveEventsMap[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 MonthPickerDirective {
+    private elementRef;
+    set formatPattern(val: MonthPickerDirectiveElement['formatPattern']);
+    get formatPattern(): MonthPickerDirectiveElement['formatPattern'];
+    set maxDate(val: MonthPickerDirectiveElement['maxDate']);
+    get maxDate(): MonthPickerDirectiveElement['maxDate'];
+    set minDate(val: MonthPickerDirectiveElement['minDate']);
+    get minDate(): MonthPickerDirectiveElement['minDate'];
+    set primaryCalendarType(val: MonthPickerDirectiveElement['primaryCalendarType']);
+    get primaryCalendarType(): MonthPickerDirectiveElement['primaryCalendarType'];
+    set secondaryCalendarType(val: MonthPickerDirectiveElement['secondaryCalendarType']);
+    get secondaryCalendarType(): MonthPickerDirectiveElement['secondaryCalendarType'];
+    set selectedDates(val: MonthPickerDirectiveElement['selectedDates']);
+    get selectedDates(): MonthPickerDirectiveElement['selectedDates'];
+    change: Observable<MonthPickerDirectiveEventsMap['change']>;
+    navigate: Observable<MonthPickerDirectiveEventsMap['navigate']>;
+    constructor(elementRef: ElementRef<MonthPickerDirectiveElement>);
+    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<MonthPickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonthPickerDirective, "ui5-monthpicker", ["ui5Monthpicker"], { "formatPattern": "formatPattern"; "maxDate": "maxDate"; "minDate": "minDate"; "primaryCalendarType": "primaryCalendarType"; "secondaryCalendarType": "secondaryCalendarType"; "selectedDates": "selectedDates"; }, { "change": "change"; "navigate": "navigate"; }, never, never, false, never>;
+}
+export { MonthPickerDirective, MonthPickerDirectiveEventsMap, MonthPickerDirectiveElement, };

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

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

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

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

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

@@ -0,0 +1,78 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/MultiComboBox.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import { IconDirective } from './icon';
+import * as i0 from "@angular/core";
+interface MultiComboBoxDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input' | 'openChange' | 'selectionChange'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+    openChange: CustomEvent<void>;
+    selectionChange: CustomEvent<{
+        items: Array<any>;
+    }>;
+}
+interface MultiComboBoxDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'allowCustomValues' | 'disabled' | 'filter' | 'noTypeahead' | 'open' | 'placeholder' | 'readonly' | 'required' | 'value' | 'valueState' | 'change' | 'input' | 'openChange' | 'selectionChange' | 'icon' | 'valueStateMessage'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    allowCustomValues: boolean;
+    disabled: boolean;
+    filter: string;
+    noTypeahead: boolean;
+    open: 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 MultiComboBoxDirectiveEventsMap>(type: K, listener: (this: MultiComboBoxDirectiveElement, ev: MultiComboBoxDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MultiComboBoxDirectiveEventsMap>(type: K, listener: (this: MultiComboBoxDirectiveElement, ev: MultiComboBoxDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class MultiComboBoxDirective {
+    private elementRef;
+    set accessibleName(val: MultiComboBoxDirectiveElement['accessibleName']);
+    get accessibleName(): MultiComboBoxDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: MultiComboBoxDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): MultiComboBoxDirectiveElement['accessibleNameRef'];
+    set allowCustomValues(val: MultiComboBoxDirectiveElement['allowCustomValues']);
+    get allowCustomValues(): MultiComboBoxDirectiveElement['allowCustomValues'];
+    set disabled(val: MultiComboBoxDirectiveElement['disabled']);
+    get disabled(): MultiComboBoxDirectiveElement['disabled'];
+    set filter(val: MultiComboBoxDirectiveElement['filter']);
+    get filter(): MultiComboBoxDirectiveElement['filter'];
+    set noTypeahead(val: MultiComboBoxDirectiveElement['noTypeahead']);
+    get noTypeahead(): MultiComboBoxDirectiveElement['noTypeahead'];
+    set open(val: MultiComboBoxDirectiveElement['open']);
+    get open(): MultiComboBoxDirectiveElement['open'];
+    set placeholder(val: MultiComboBoxDirectiveElement['placeholder']);
+    get placeholder(): MultiComboBoxDirectiveElement['placeholder'];
+    set readonly(val: MultiComboBoxDirectiveElement['readonly']);
+    get readonly(): MultiComboBoxDirectiveElement['readonly'];
+    set required(val: MultiComboBoxDirectiveElement['required']);
+    get required(): MultiComboBoxDirectiveElement['required'];
+    set value(val: MultiComboBoxDirectiveElement['value']);
+    get value(): MultiComboBoxDirectiveElement['value'];
+    set valueState(val: MultiComboBoxDirectiveElement['valueState']);
+    get valueState(): MultiComboBoxDirectiveElement['valueState'];
+    change: Observable<MultiComboBoxDirectiveEventsMap['change']>;
+    input: Observable<MultiComboBoxDirectiveEventsMap['input']>;
+    openChange: Observable<MultiComboBoxDirectiveEventsMap['openChange']>;
+    selectionChange: Observable<MultiComboBoxDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<MultiComboBoxDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get icon(): IconDirective['element'];
+    get valueStateMessage(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiComboBoxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiComboBoxDirective, "ui5-multi-combobox", ["ui5MultiCombobox"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "allowCustomValues": "allowCustomValues"; "disabled": "disabled"; "filter": "filter"; "noTypeahead": "noTypeahead"; "open": "open"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "value": "value"; "valueState": "valueState"; }, { "change": "change"; "input": "input"; "openChange": "openChange"; "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+declare class MultiComboBoxDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<MultiComboBoxDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiComboBoxDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiComboBoxDirectiveCva, "ui5-multi-combobox", never, {}, {}, never, never, false, never>;
+}
+export { MultiComboBoxDirective, MultiComboBoxDirectiveCva, MultiComboBoxDirectiveEventsMap, MultiComboBoxDirectiveElement, };

package/main/directives/multi-input.d.ts

@@ -0,0 +1,110 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/MultiInput.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 { TokenDirective } from './token';
+import * as i0 from "@angular/core";
+interface MultiInputDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input' | 'suggestionItemPreview' | 'suggestionItemSelect' | 'tokenDelete' | 'valueHelpTrigger'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+    suggestionItemPreview: CustomEvent<{
+        item: HTMLElement;
+        targetRef: HTMLElement;
+    }>;
+    suggestionItemSelect: CustomEvent<{
+        item: HTMLElement;
+    }>;
+    tokenDelete: CustomEvent<{
+        token: HTMLElement;
+    }>;
+    valueHelpTrigger: CustomEvent<void>;
+}
+interface MultiInputDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'maxlength' | 'name' | 'noTypeahead' | 'placeholder' | 'previewItem' | 'readonly' | 'required' | 'showClearIcon' | 'showSuggestions' | 'type' | 'value' | 'valueState' | 'showValueHelpIcon' | 'change' | 'input' | 'suggestionItemPreview' | 'suggestionItemSelect' | 'tokenDelete' | 'valueHelpTrigger' | 'icon' | 'valueStateMessage' | 'tokens'> {
+    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';
+    showValueHelpIcon: boolean;
+    icon: Array<IconDirective['element']>;
+    valueStateMessage: Array<HTMLElement>;
+    tokens: Array<TokenDirective['element']>;
+    addEventListener<K extends keyof MultiInputDirectiveEventsMap>(type: K, listener: (this: MultiInputDirectiveElement, ev: MultiInputDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MultiInputDirectiveEventsMap>(type: K, listener: (this: MultiInputDirectiveElement, ev: MultiInputDirectiveEventsMap[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 MultiInputDirective {
+    private elementRef;
+    set accessibleName(val: MultiInputDirectiveElement['accessibleName']);
+    get accessibleName(): MultiInputDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: MultiInputDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): MultiInputDirectiveElement['accessibleNameRef'];
+    set disabled(val: MultiInputDirectiveElement['disabled']);
+    get disabled(): MultiInputDirectiveElement['disabled'];
+    set maxlength(val: MultiInputDirectiveElement['maxlength']);
+    get maxlength(): MultiInputDirectiveElement['maxlength'];
+    set name(val: MultiInputDirectiveElement['name']);
+    get name(): MultiInputDirectiveElement['name'];
+    set noTypeahead(val: MultiInputDirectiveElement['noTypeahead']);
+    get noTypeahead(): MultiInputDirectiveElement['noTypeahead'];
+    set placeholder(val: MultiInputDirectiveElement['placeholder']);
+    get placeholder(): MultiInputDirectiveElement['placeholder'];
+    set previewItem(val: MultiInputDirectiveElement['previewItem']);
+    get previewItem(): MultiInputDirectiveElement['previewItem'];
+    set readonly(val: MultiInputDirectiveElement['readonly']);
+    get readonly(): MultiInputDirectiveElement['readonly'];
+    set required(val: MultiInputDirectiveElement['required']);
+    get required(): MultiInputDirectiveElement['required'];
+    set showClearIcon(val: MultiInputDirectiveElement['showClearIcon']);
+    get showClearIcon(): MultiInputDirectiveElement['showClearIcon'];
+    set showSuggestions(val: MultiInputDirectiveElement['showSuggestions']);
+    get showSuggestions(): MultiInputDirectiveElement['showSuggestions'];
+    set type(val: MultiInputDirectiveElement['type']);
+    get type(): MultiInputDirectiveElement['type'];
+    set value(val: MultiInputDirectiveElement['value']);
+    get value(): MultiInputDirectiveElement['value'];
+    set valueState(val: MultiInputDirectiveElement['valueState']);
+    get valueState(): MultiInputDirectiveElement['valueState'];
+    set showValueHelpIcon(val: MultiInputDirectiveElement['showValueHelpIcon']);
+    get showValueHelpIcon(): MultiInputDirectiveElement['showValueHelpIcon'];
+    change: Observable<MultiInputDirectiveEventsMap['change']>;
+    input: Observable<MultiInputDirectiveEventsMap['input']>;
+    suggestionItemPreview: Observable<MultiInputDirectiveEventsMap['suggestionItemPreview']>;
+    suggestionItemSelect: Observable<MultiInputDirectiveEventsMap['suggestionItemSelect']>;
+    tokenDelete: Observable<MultiInputDirectiveEventsMap['tokenDelete']>;
+    valueHelpTrigger: Observable<MultiInputDirectiveEventsMap['valueHelpTrigger']>;
+    constructor(elementRef: ElementRef<MultiInputDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get icon(): Array<IconDirective['element']>;
+    get valueStateMessage(): Array<HTMLElement>;
+    get tokens(): Array<TokenDirective['element']>;
+    getCaretPosition(): any;
+    openPicker(): any;
+    setCaretPosition(pos: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiInputDirective, "ui5-multi-input", ["ui5MultiInput"], { "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"; "showValueHelpIcon": "showValueHelpIcon"; }, { "change": "change"; "input": "input"; "suggestionItemPreview": "suggestionItemPreview"; "suggestionItemSelect": "suggestionItemSelect"; "tokenDelete": "tokenDelete"; "valueHelpTrigger": "valueHelpTrigger"; }, never, never, false, never>;
+}
+declare class MultiInputDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<MultiInputDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiInputDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiInputDirectiveCva, "ui5-multi-input", never, {}, {}, never, never, false, never>;
+}
+export { MultiInputDirective, MultiInputDirectiveCva, MultiInputDirectiveEventsMap, MultiInputDirectiveElement, };

package/main/directives/option.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Option.js';
+import * as i0 from "@angular/core";
+interface OptionDirectiveElement extends Omit<HTMLElement, 'additionalText' | 'disabled' | 'icon' | 'selected' | 'value'> {
+    additionalText: string;
+    disabled: boolean;
+    icon: string;
+    selected: boolean;
+    value: string;
+}
+declare class OptionDirective {
+    private elementRef;
+    set additionalText(val: OptionDirectiveElement['additionalText']);
+    get additionalText(): OptionDirectiveElement['additionalText'];
+    set disabled(val: OptionDirectiveElement['disabled']);
+    get disabled(): OptionDirectiveElement['disabled'];
+    set icon(val: OptionDirectiveElement['icon']);
+    get icon(): OptionDirectiveElement['icon'];
+    set selected(val: OptionDirectiveElement['selected']);
+    get selected(): OptionDirectiveElement['selected'];
+    set value(val: OptionDirectiveElement['value']);
+    get value(): OptionDirectiveElement['value'];
+    constructor(elementRef: ElementRef<OptionDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OptionDirective, "ui5-option", ["ui5Option"], { "additionalText": "additionalText"; "disabled": "disabled"; "icon": "icon"; "selected": "selected"; "value": "value"; }, {}, never, never, false, never>;
+}
+export { OptionDirective, OptionDirectiveElement };

package/main/directives/panel.d.ts

@@ -0,0 +1,45 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Panel.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface PanelDirectiveEventsMap extends Omit<HTMLElementEventMap, 'toggle'> {
+    toggle: CustomEvent<void>;
+}
+interface PanelDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleRole' | 'collapsed' | 'fixed' | 'headerLevel' | 'headerText' | 'noAnimation' | 'toggle' | 'header'> {
+    accessibleName: string;
+    accessibleRole: 'Complementary' | 'Form' | 'Region';
+    collapsed: boolean;
+    fixed: boolean;
+    headerLevel: 'H1' | 'H2' | 'H3' | 'H4' | 'H5' | 'H6';
+    headerText: string;
+    noAnimation: boolean;
+    header: Array<HTMLElement>;
+    addEventListener<K extends keyof PanelDirectiveEventsMap>(type: K, listener: (this: PanelDirectiveElement, ev: PanelDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof PanelDirectiveEventsMap>(type: K, listener: (this: PanelDirectiveElement, ev: PanelDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class PanelDirective {
+    private elementRef;
+    set accessibleName(val: PanelDirectiveElement['accessibleName']);
+    get accessibleName(): PanelDirectiveElement['accessibleName'];
+    set accessibleRole(val: PanelDirectiveElement['accessibleRole']);
+    get accessibleRole(): PanelDirectiveElement['accessibleRole'];
+    set collapsed(val: PanelDirectiveElement['collapsed']);
+    get collapsed(): PanelDirectiveElement['collapsed'];
+    set fixed(val: PanelDirectiveElement['fixed']);
+    get fixed(): PanelDirectiveElement['fixed'];
+    set headerLevel(val: PanelDirectiveElement['headerLevel']);
+    get headerLevel(): PanelDirectiveElement['headerLevel'];
+    set headerText(val: PanelDirectiveElement['headerText']);
+    get headerText(): PanelDirectiveElement['headerText'];
+    set noAnimation(val: PanelDirectiveElement['noAnimation']);
+    get noAnimation(): PanelDirectiveElement['noAnimation'];
+    toggle: Observable<PanelDirectiveEventsMap['toggle']>;
+    constructor(elementRef: ElementRef<PanelDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get header(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PanelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PanelDirective, "ui5-panel", ["ui5Panel"], { "accessibleName": "accessibleName"; "accessibleRole": "accessibleRole"; "collapsed": "collapsed"; "fixed": "fixed"; "headerLevel": "headerLevel"; "headerText": "headerText"; "noAnimation": "noAnimation"; }, { "toggle": "toggle"; }, never, never, false, never>;
+}
+export { PanelDirective, PanelDirectiveEventsMap, PanelDirectiveElement };

package/main/directives/popover.d.ts

@@ -0,0 +1,102 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Popover.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface PopoverDirectiveEventsMap extends Omit<HTMLElementEventMap, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen'> {
+    afterClose: CustomEvent<void>;
+    afterOpen: CustomEvent<void>;
+    beforeClose: CustomEvent<{
+        escPressed: boolean;
+    }>;
+    beforeOpen: CustomEvent<void>;
+}
+interface PopoverDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'initialFocus' | 'open' | 'preventFocusRestore' | 'allowTargetOverlap' | 'headerText' | 'hideArrow' | 'hideBackdrop' | 'horizontalAlign' | 'modal' | 'opener' | 'placementType' | 'verticalAlign' | 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen' | 'footer' | 'header'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    initialFocus: string;
+    open: boolean;
+    preventFocusRestore: boolean;
+    allowTargetOverlap: boolean;
+    headerText: string;
+    hideArrow: boolean;
+    hideBackdrop: boolean;
+    horizontalAlign: 'Center' | 'Left' | 'Right' | 'Stretch';
+    modal: boolean;
+    opener: any;
+    placementType: 'Bottom' | 'Left' | 'Right' | 'Top';
+    verticalAlign: 'Bottom' | 'Center' | 'Stretch' | 'Top';
+    footer: Array<HTMLElement>;
+    header: Array<HTMLElement>;
+    addEventListener<K extends keyof PopoverDirectiveEventsMap>(type: K, listener: (this: PopoverDirectiveElement, ev: PopoverDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof PopoverDirectiveEventsMap>(type: K, listener: (this: PopoverDirectiveElement, ev: PopoverDirectiveEventsMap[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;
+    showAt(opener: HTMLElement, preventInitialFocus: boolean): any;
+}
+declare class PopoverDirective {
+    private elementRef;
+    set accessibleName(val: PopoverDirectiveElement['accessibleName']);
+    get accessibleName(): PopoverDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: PopoverDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): PopoverDirectiveElement['accessibleNameRef'];
+    set initialFocus(val: PopoverDirectiveElement['initialFocus']);
+    get initialFocus(): PopoverDirectiveElement['initialFocus'];
+    set open(val: PopoverDirectiveElement['open']);
+    get open(): PopoverDirectiveElement['open'];
+    set preventFocusRestore(val: PopoverDirectiveElement['preventFocusRestore']);
+    get preventFocusRestore(): PopoverDirectiveElement['preventFocusRestore'];
+    set allowTargetOverlap(val: PopoverDirectiveElement['allowTargetOverlap']);
+    get allowTargetOverlap(): PopoverDirectiveElement['allowTargetOverlap'];
+    set headerText(val: PopoverDirectiveElement['headerText']);
+    get headerText(): PopoverDirectiveElement['headerText'];
+    set hideArrow(val: PopoverDirectiveElement['hideArrow']);
+    get hideArrow(): PopoverDirectiveElement['hideArrow'];
+    set hideBackdrop(val: PopoverDirectiveElement['hideBackdrop']);
+    get hideBackdrop(): PopoverDirectiveElement['hideBackdrop'];
+    set horizontalAlign(val: PopoverDirectiveElement['horizontalAlign']);
+    get horizontalAlign(): PopoverDirectiveElement['horizontalAlign'];
+    set modal(val: PopoverDirectiveElement['modal']);
+    get modal(): PopoverDirectiveElement['modal'];
+    set opener(val: PopoverDirectiveElement['opener']);
+    get opener(): PopoverDirectiveElement['opener'];
+    set placementType(val: PopoverDirectiveElement['placementType']);
+    get placementType(): PopoverDirectiveElement['placementType'];
+    set verticalAlign(val: PopoverDirectiveElement['verticalAlign']);
+    get verticalAlign(): PopoverDirectiveElement['verticalAlign'];
+    afterClose: Observable<PopoverDirectiveEventsMap['afterClose']>;
+    afterOpen: Observable<PopoverDirectiveEventsMap['afterOpen']>;
+    beforeClose: Observable<PopoverDirectiveEventsMap['beforeClose']>;
+    beforeOpen: Observable<PopoverDirectiveEventsMap['beforeOpen']>;
+    constructor(elementRef: ElementRef<PopoverDirectiveElement>);
+    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;
+    showAt(opener: HTMLElement, preventInitialFocus: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverDirective, "ui5-popover", ["ui5Popover"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "initialFocus": "initialFocus"; "open": "open"; "preventFocusRestore": "preventFocusRestore"; "allowTargetOverlap": "allowTargetOverlap"; "headerText": "headerText"; "hideArrow": "hideArrow"; "hideBackdrop": "hideBackdrop"; "horizontalAlign": "horizontalAlign"; "modal": "modal"; "opener": "opener"; "placementType": "placementType"; "verticalAlign": "verticalAlign"; }, { "afterClose": "afterClose"; "afterOpen": "afterOpen"; "beforeClose": "beforeClose"; "beforeOpen": "beforeOpen"; }, never, never, false, never>;
+}
+export { PopoverDirective, PopoverDirectiveEventsMap, PopoverDirectiveElement };

package/main/directives/progress-indicator.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ProgressIndicator.js';
+import * as i0 from "@angular/core";
+interface ProgressIndicatorDirectiveElement extends Omit<HTMLElement, 'disabled' | 'displayValue' | 'hideValue' | 'value' | 'valueState'> {
+    disabled: boolean;
+    displayValue: string;
+    hideValue: boolean;
+    value: any;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+}
+declare class ProgressIndicatorDirective {
+    private elementRef;
+    set disabled(val: ProgressIndicatorDirectiveElement['disabled']);
+    get disabled(): ProgressIndicatorDirectiveElement['disabled'];
+    set displayValue(val: ProgressIndicatorDirectiveElement['displayValue']);
+    get displayValue(): ProgressIndicatorDirectiveElement['displayValue'];
+    set hideValue(val: ProgressIndicatorDirectiveElement['hideValue']);
+    get hideValue(): ProgressIndicatorDirectiveElement['hideValue'];
+    set value(val: ProgressIndicatorDirectiveElement['value']);
+    get value(): ProgressIndicatorDirectiveElement['value'];
+    set valueState(val: ProgressIndicatorDirectiveElement['valueState']);
+    get valueState(): ProgressIndicatorDirectiveElement['valueState'];
+    constructor(elementRef: ElementRef<ProgressIndicatorDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ProgressIndicatorDirective, "ui5-progress-indicator", ["ui5ProgressIndicator"], { "disabled": "disabled"; "displayValue": "displayValue"; "hideValue": "hideValue"; "value": "value"; "valueState": "valueState"; }, {}, never, never, false, never>;
+}
+export { ProgressIndicatorDirective, ProgressIndicatorDirectiveElement };

package/main/directives/radio-button.d.ts

@@ -0,0 +1,62 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/RadioButton.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface RadioButtonDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<void>;
+}
+interface RadioButtonDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'checked' | 'disabled' | 'name' | 'readonly' | 'required' | 'text' | 'value' | 'valueState' | 'wrappingType' | 'change'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    checked: boolean;
+    disabled: boolean;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    text: string;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    wrappingType: 'None' | 'Normal';
+    addEventListener<K extends keyof RadioButtonDirectiveEventsMap>(type: K, listener: (this: RadioButtonDirectiveElement, ev: RadioButtonDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof RadioButtonDirectiveEventsMap>(type: K, listener: (this: RadioButtonDirectiveElement, ev: RadioButtonDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class RadioButtonDirective {
+    private elementRef;
+    set accessibleName(val: RadioButtonDirectiveElement['accessibleName']);
+    get accessibleName(): RadioButtonDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: RadioButtonDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): RadioButtonDirectiveElement['accessibleNameRef'];
+    set checked(val: RadioButtonDirectiveElement['checked']);
+    get checked(): RadioButtonDirectiveElement['checked'];
+    set disabled(val: RadioButtonDirectiveElement['disabled']);
+    get disabled(): RadioButtonDirectiveElement['disabled'];
+    set name(val: RadioButtonDirectiveElement['name']);
+    get name(): RadioButtonDirectiveElement['name'];
+    set readonly(val: RadioButtonDirectiveElement['readonly']);
+    get readonly(): RadioButtonDirectiveElement['readonly'];
+    set required(val: RadioButtonDirectiveElement['required']);
+    get required(): RadioButtonDirectiveElement['required'];
+    set text(val: RadioButtonDirectiveElement['text']);
+    get text(): RadioButtonDirectiveElement['text'];
+    set value(val: RadioButtonDirectiveElement['value']);
+    get value(): RadioButtonDirectiveElement['value'];
+    set valueState(val: RadioButtonDirectiveElement['valueState']);
+    get valueState(): RadioButtonDirectiveElement['valueState'];
+    set wrappingType(val: RadioButtonDirectiveElement['wrappingType']);
+    get wrappingType(): RadioButtonDirectiveElement['wrappingType'];
+    change: Observable<RadioButtonDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<RadioButtonDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioButtonDirective, "ui5-radio-button", ["ui5RadioButton"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "checked": "checked"; "disabled": "disabled"; "name": "name"; "readonly": "readonly"; "required": "required"; "text": "text"; "value": "value"; "valueState": "valueState"; "wrappingType": "wrappingType"; }, { "change": "change"; }, never, never, false, never>;
+}
+declare class RadioButtonDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<RadioButtonDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioButtonDirectiveCva, "ui5-radio-button", never, {}, {}, never, never, false, never>;
+}
+export { RadioButtonDirective, RadioButtonDirectiveCva, RadioButtonDirectiveEventsMap, RadioButtonDirectiveElement, };