@ui5/webcomponents-ngx 0.0.1-rc.0

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

@@ -0,0 +1,63 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/StepInput.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface StepInputDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<void>;
+}
+interface StepInputDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'max' | 'min' | 'name' | 'placeholder' | 'readonly' | 'required' | 'step' | 'value' | 'valuePrecision' | 'valueState' | 'change' | 'valueStateMessage'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    disabled: boolean;
+    max: any;
+    min: any;
+    name: string;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    step: any;
+    value: any;
+    valuePrecision: any;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    valueStateMessage: HTMLElement;
+    addEventListener<K extends keyof StepInputDirectiveEventsMap>(type: K, listener: (this: StepInputDirectiveElement, ev: StepInputDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof StepInputDirectiveEventsMap>(type: K, listener: (this: StepInputDirectiveElement, ev: StepInputDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class StepInputDirective {
+    private elementRef;
+    set accessibleName(val: StepInputDirectiveElement['accessibleName']);
+    get accessibleName(): StepInputDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: StepInputDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): StepInputDirectiveElement['accessibleNameRef'];
+    set disabled(val: StepInputDirectiveElement['disabled']);
+    get disabled(): StepInputDirectiveElement['disabled'];
+    set max(val: StepInputDirectiveElement['max']);
+    get max(): StepInputDirectiveElement['max'];
+    set min(val: StepInputDirectiveElement['min']);
+    get min(): StepInputDirectiveElement['min'];
+    set name(val: StepInputDirectiveElement['name']);
+    get name(): StepInputDirectiveElement['name'];
+    set placeholder(val: StepInputDirectiveElement['placeholder']);
+    get placeholder(): StepInputDirectiveElement['placeholder'];
+    set readonly(val: StepInputDirectiveElement['readonly']);
+    get readonly(): StepInputDirectiveElement['readonly'];
+    set required(val: StepInputDirectiveElement['required']);
+    get required(): StepInputDirectiveElement['required'];
+    set step(val: StepInputDirectiveElement['step']);
+    get step(): StepInputDirectiveElement['step'];
+    set value(val: StepInputDirectiveElement['value']);
+    get value(): StepInputDirectiveElement['value'];
+    set valuePrecision(val: StepInputDirectiveElement['valuePrecision']);
+    get valuePrecision(): StepInputDirectiveElement['valuePrecision'];
+    set valueState(val: StepInputDirectiveElement['valueState']);
+    get valueState(): StepInputDirectiveElement['valueState'];
+    change: Observable<StepInputDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<StepInputDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StepInputDirective, "ui5-step-input", ["ui5StepInput"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "disabled": "disabled"; "max": "max"; "min": "min"; "name": "name"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "step": "step"; "value": "value"; "valuePrecision": "valuePrecision"; "valueState": "valueState"; }, { "change": "change"; }, never, never, false, never>;
+}
+export { StepInputDirective, StepInputDirectiveEventsMap, StepInputDirectiveElement, };

package/main/directives/suggestion-group-item.d.ts

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

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

@@ -0,0 +1,37 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/SuggestionItem.js';
+import * as i0 from "@angular/core";
+interface SuggestionItemDirectiveElement extends Omit<HTMLElement, 'additionalText' | 'additionalTextState' | 'description' | 'icon' | 'iconEnd' | 'image' | 'text' | 'type'> {
+    additionalText: string;
+    additionalTextState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    description: string;
+    icon: string;
+    iconEnd: boolean;
+    image: string;
+    text: string;
+    type: 'Active' | 'Detail' | 'Inactive';
+}
+declare class SuggestionItemDirective {
+    private elementRef;
+    set additionalText(val: SuggestionItemDirectiveElement['additionalText']);
+    get additionalText(): SuggestionItemDirectiveElement['additionalText'];
+    set additionalTextState(val: SuggestionItemDirectiveElement['additionalTextState']);
+    get additionalTextState(): SuggestionItemDirectiveElement['additionalTextState'];
+    set description(val: SuggestionItemDirectiveElement['description']);
+    get description(): SuggestionItemDirectiveElement['description'];
+    set icon(val: SuggestionItemDirectiveElement['icon']);
+    get icon(): SuggestionItemDirectiveElement['icon'];
+    set iconEnd(val: SuggestionItemDirectiveElement['iconEnd']);
+    get iconEnd(): SuggestionItemDirectiveElement['iconEnd'];
+    set image(val: SuggestionItemDirectiveElement['image']);
+    get image(): SuggestionItemDirectiveElement['image'];
+    set text(val: SuggestionItemDirectiveElement['text']);
+    get text(): SuggestionItemDirectiveElement['text'];
+    set type(val: SuggestionItemDirectiveElement['type']);
+    get type(): SuggestionItemDirectiveElement['type'];
+    constructor(elementRef: ElementRef<SuggestionItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuggestionItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SuggestionItemDirective, "ui5-suggestion-item", ["ui5SuggestionItem"], { "additionalText": "additionalText"; "additionalTextState": "additionalTextState"; "description": "description"; "icon": "icon"; "iconEnd": "iconEnd"; "image": "image"; "text": "text"; "type": "type"; }, {}, never, never, false, never>;
+}
+export { SuggestionItemDirective, SuggestionItemDirectiveElement };

package/main/directives/switch.d.ts

@@ -0,0 +1,53 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Switch.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface SwitchDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<void>;
+}
+interface SwitchDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'checked' | 'design' | 'disabled' | 'textOff' | 'textOn' | 'tooltip' | 'change'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    checked: boolean;
+    design: 'Graphical' | 'Textual';
+    disabled: boolean;
+    textOff: string;
+    textOn: string;
+    tooltip: string;
+    addEventListener<K extends keyof SwitchDirectiveEventsMap>(type: K, listener: (this: SwitchDirectiveElement, ev: SwitchDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SwitchDirectiveEventsMap>(type: K, listener: (this: SwitchDirectiveElement, ev: SwitchDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class SwitchDirective {
+    private elementRef;
+    set accessibleName(val: SwitchDirectiveElement['accessibleName']);
+    get accessibleName(): SwitchDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: SwitchDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): SwitchDirectiveElement['accessibleNameRef'];
+    set checked(val: SwitchDirectiveElement['checked']);
+    get checked(): SwitchDirectiveElement['checked'];
+    set design(val: SwitchDirectiveElement['design']);
+    get design(): SwitchDirectiveElement['design'];
+    set disabled(val: SwitchDirectiveElement['disabled']);
+    get disabled(): SwitchDirectiveElement['disabled'];
+    set textOff(val: SwitchDirectiveElement['textOff']);
+    get textOff(): SwitchDirectiveElement['textOff'];
+    set textOn(val: SwitchDirectiveElement['textOn']);
+    get textOn(): SwitchDirectiveElement['textOn'];
+    set tooltip(val: SwitchDirectiveElement['tooltip']);
+    get tooltip(): SwitchDirectiveElement['tooltip'];
+    change: Observable<SwitchDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<SwitchDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SwitchDirective, "ui5-switch", ["ui5Switch"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "checked": "checked"; "design": "design"; "disabled": "disabled"; "textOff": "textOff"; "textOn": "textOn"; "tooltip": "tooltip"; }, { "change": "change"; }, never, never, false, never>;
+}
+declare class SwitchDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<SwitchDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SwitchDirectiveCva, "ui5-switch", never, {}, {}, never, never, false, never>;
+}
+export { SwitchDirective, SwitchDirectiveCva, SwitchDirectiveEventsMap, SwitchDirectiveElement, };

package/main/directives/tab-container.d.ts

@@ -0,0 +1,56 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TabContainer.js';
+import { TabDirective } from './tab';
+import { TabSeparatorDirective } from './tab-separator';
+import { Observable } from 'rxjs';
+import { ButtonDirective } from './button';
+import * as i0 from "@angular/core";
+interface TabContainerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'tabSelect'> {
+    tabSelect: CustomEvent<{
+        tab: HTMLElement;
+        tabIndex: number;
+    }>;
+}
+interface TabContainerDirectiveElement extends Omit<HTMLElement, 'allItems' | 'collapsed' | 'contentBackgroundDesign' | 'fixed' | 'headerBackgroundDesign' | 'showOverflow' | 'tabLayout' | 'tabsOverflowMode' | 'tabSelect' | 'overflowButton' | 'startOverflowButton'> {
+    allItems: Array<TabDirective['element'] | TabSeparatorDirective['element']>;
+    collapsed: boolean;
+    contentBackgroundDesign: 'Solid' | 'Translucent' | 'Transparent';
+    fixed: boolean;
+    headerBackgroundDesign: 'Solid' | 'Translucent' | 'Transparent';
+    showOverflow: boolean;
+    tabLayout: 'Inline' | 'Standard';
+    tabsOverflowMode: 'End' | 'StartAndEnd';
+    overflowButton: ButtonDirective['element'];
+    startOverflowButton: ButtonDirective['element'];
+    addEventListener<K extends keyof TabContainerDirectiveEventsMap>(type: K, listener: (this: TabContainerDirectiveElement, ev: TabContainerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof TabContainerDirectiveEventsMap>(type: K, listener: (this: TabContainerDirectiveElement, ev: TabContainerDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class TabContainerDirective {
+    private elementRef;
+    set allItems(val: TabContainerDirectiveElement['allItems']);
+    get allItems(): TabContainerDirectiveElement['allItems'];
+    set collapsed(val: TabContainerDirectiveElement['collapsed']);
+    get collapsed(): TabContainerDirectiveElement['collapsed'];
+    set contentBackgroundDesign(val: TabContainerDirectiveElement['contentBackgroundDesign']);
+    get contentBackgroundDesign(): TabContainerDirectiveElement['contentBackgroundDesign'];
+    set fixed(val: TabContainerDirectiveElement['fixed']);
+    get fixed(): TabContainerDirectiveElement['fixed'];
+    set headerBackgroundDesign(val: TabContainerDirectiveElement['headerBackgroundDesign']);
+    get headerBackgroundDesign(): TabContainerDirectiveElement['headerBackgroundDesign'];
+    set showOverflow(val: TabContainerDirectiveElement['showOverflow']);
+    get showOverflow(): TabContainerDirectiveElement['showOverflow'];
+    set tabLayout(val: TabContainerDirectiveElement['tabLayout']);
+    get tabLayout(): TabContainerDirectiveElement['tabLayout'];
+    set tabsOverflowMode(val: TabContainerDirectiveElement['tabsOverflowMode']);
+    get tabsOverflowMode(): TabContainerDirectiveElement['tabsOverflowMode'];
+    tabSelect: Observable<TabContainerDirectiveEventsMap['tabSelect']>;
+    constructor(elementRef: ElementRef<TabContainerDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get overflowButton(): ButtonDirective['element'];
+    get startOverflowButton(): ButtonDirective['element'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabContainerDirective, "ui5-tabcontainer", ["ui5Tabcontainer"], { "allItems": "allItems"; "collapsed": "collapsed"; "contentBackgroundDesign": "contentBackgroundDesign"; "fixed": "fixed"; "headerBackgroundDesign": "headerBackgroundDesign"; "showOverflow": "showOverflow"; "tabLayout": "tabLayout"; "tabsOverflowMode": "tabsOverflowMode"; }, { "tabSelect": "tabSelect"; }, never, never, false, never>;
+}
+export { TabContainerDirective, TabContainerDirectiveEventsMap, TabContainerDirectiveElement, };

package/main/directives/tab-separator.d.ts

@@ -0,0 +1,15 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TabSeparator.js';
+import * as i0 from "@angular/core";
+interface TabSeparatorDirectiveElement extends HTMLElement {
+    getTabInStripDomRef(): any;
+}
+declare class TabSeparatorDirective {
+    private elementRef;
+    constructor(elementRef: ElementRef<TabSeparatorDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    getTabInStripDomRef(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabSeparatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabSeparatorDirective, "ui5-tab-separator", ["ui5TabSeparator"], {}, {}, never, never, false, never>;
+}
+export { TabSeparatorDirective, TabSeparatorDirectiveElement };

package/main/directives/tab.d.ts

@@ -0,0 +1,36 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Tab.js';
+import { TabSeparatorDirective } from './tab-separator';
+import * as i0 from "@angular/core";
+interface TabDirectiveElement extends Omit<HTMLElement, 'additionalText' | 'design' | 'disabled' | 'icon' | 'selected' | 'text' | 'subTabs'> {
+    additionalText: string;
+    design: 'Critical' | 'Default' | 'Negative' | 'Neutral' | 'Positive';
+    disabled: boolean;
+    icon: string;
+    selected: boolean;
+    text: string;
+    subTabs: Array<TabSeparatorDirective['element'] | TabDirective['element']>;
+    getTabInStripDomRef(): any;
+}
+declare class TabDirective {
+    private elementRef;
+    set additionalText(val: TabDirectiveElement['additionalText']);
+    get additionalText(): TabDirectiveElement['additionalText'];
+    set design(val: TabDirectiveElement['design']);
+    get design(): TabDirectiveElement['design'];
+    set disabled(val: TabDirectiveElement['disabled']);
+    get disabled(): TabDirectiveElement['disabled'];
+    set icon(val: TabDirectiveElement['icon']);
+    get icon(): TabDirectiveElement['icon'];
+    set selected(val: TabDirectiveElement['selected']);
+    get selected(): TabDirectiveElement['selected'];
+    set text(val: TabDirectiveElement['text']);
+    get text(): TabDirectiveElement['text'];
+    constructor(elementRef: ElementRef<TabDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get subTabs(): Array<TabSeparatorDirective['element'] | TabDirective['element']>;
+    getTabInStripDomRef(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabDirective, "ui5-tab", ["ui5Tab"], { "additionalText": "additionalText"; "design": "design"; "disabled": "disabled"; "icon": "icon"; "selected": "selected"; "text": "text"; }, {}, never, never, false, never>;
+}
+export { TabDirective, TabDirectiveElement };

package/main/directives/table-cell.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TableCell.js';
+import * as i0 from "@angular/core";
+interface TableCellDirectiveElement extends HTMLElement {
+}
+declare class TableCellDirective {
+    private elementRef;
+    constructor(elementRef: ElementRef<TableCellDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "ui5-table-cell", ["ui5TableCell"], {}, {}, never, never, false, never>;
+}
+export { TableCellDirective, TableCellDirectiveElement };

package/main/directives/table-column.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TableColumn.js';
+import * as i0 from "@angular/core";
+interface TableColumnDirectiveElement extends Omit<HTMLElement, 'demandPopin' | 'minWidth' | 'popinText'> {
+    demandPopin: boolean;
+    minWidth: any;
+    popinText: string;
+}
+declare class TableColumnDirective {
+    private elementRef;
+    set demandPopin(val: TableColumnDirectiveElement['demandPopin']);
+    get demandPopin(): TableColumnDirectiveElement['demandPopin'];
+    set minWidth(val: TableColumnDirectiveElement['minWidth']);
+    get minWidth(): TableColumnDirectiveElement['minWidth'];
+    set popinText(val: TableColumnDirectiveElement['popinText']);
+    get popinText(): TableColumnDirectiveElement['popinText'];
+    constructor(elementRef: ElementRef<TableColumnDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableColumnDirective, "ui5-table-column", ["ui5TableColumn"], { "demandPopin": "demandPopin"; "minWidth": "minWidth"; "popinText": "popinText"; }, {}, never, never, false, never>;
+}
+export { TableColumnDirective, TableColumnDirectiveElement };

package/main/directives/table-group-row.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TableGroupRow.js';
+import * as i0 from "@angular/core";
+interface TableGroupRowDirectiveElement extends HTMLElement {
+}
+declare class TableGroupRowDirective {
+    private elementRef;
+    constructor(elementRef: ElementRef<TableGroupRowDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableGroupRowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableGroupRowDirective, "ui5-table-group-row", ["ui5TableGroupRow"], {}, {}, never, never, false, never>;
+}
+export { TableGroupRowDirective, TableGroupRowDirectiveElement };

package/main/directives/table-row.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TableRow.js';
+import * as i0 from "@angular/core";
+interface TableRowDirectiveElement extends Omit<HTMLElement, 'navigated' | 'selected' | 'type'> {
+    navigated: boolean;
+    selected: boolean;
+    type: 'Active' | 'Inactive';
+}
+declare class TableRowDirective {
+    private elementRef;
+    set navigated(val: TableRowDirectiveElement['navigated']);
+    get navigated(): TableRowDirectiveElement['navigated'];
+    set selected(val: TableRowDirectiveElement['selected']);
+    get selected(): TableRowDirectiveElement['selected'];
+    set type(val: TableRowDirectiveElement['type']);
+    get type(): TableRowDirectiveElement['type'];
+    constructor(elementRef: ElementRef<TableRowDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowDirective, "ui5-table-row", ["ui5TableRow"], { "navigated": "navigated"; "selected": "selected"; "type": "type"; }, {}, never, never, false, never>;
+}
+export { TableRowDirective, TableRowDirectiveElement };

package/main/directives/table.d.ts

@@ -0,0 +1,71 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Table.js';
+import { Observable } from 'rxjs';
+import { TableColumnDirective } from './table-column';
+import * as i0 from "@angular/core";
+interface TableDirectiveEventsMap extends Omit<HTMLElementEventMap, 'loadMore' | 'popinChange' | 'rowClick' | 'selectionChange'> {
+    loadMore: CustomEvent<void>;
+    popinChange: CustomEvent<{
+        poppedColumns: Array<any>;
+    }>;
+    rowClick: CustomEvent<{
+        row: HTMLElement;
+    }>;
+    selectionChange: CustomEvent<{
+        selectedRows: Array<any>;
+        previouslySelectedRows: Array<any>;
+    }>;
+}
+interface TableDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'busy' | 'busyDelay' | 'growing' | 'growingButtonSubtext' | 'growingButtonText' | 'hideNoData' | 'mode' | 'noDataText' | 'stickyColumnHeader' | 'loadMore' | 'popinChange' | 'rowClick' | 'selectionChange' | 'columns'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    busy: boolean;
+    busyDelay: any;
+    growing: 'Button' | 'None' | 'Scroll';
+    growingButtonSubtext: string;
+    growingButtonText: string;
+    hideNoData: boolean;
+    mode: 'MultiSelect' | 'None' | 'SingleSelect';
+    noDataText: string;
+    stickyColumnHeader: boolean;
+    columns: Array<TableColumnDirective['element']>;
+    addEventListener<K extends keyof TableDirectiveEventsMap>(type: K, listener: (this: TableDirectiveElement, ev: TableDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof TableDirectiveEventsMap>(type: K, listener: (this: TableDirectiveElement, ev: TableDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class TableDirective {
+    private elementRef;
+    set accessibleName(val: TableDirectiveElement['accessibleName']);
+    get accessibleName(): TableDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: TableDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): TableDirectiveElement['accessibleNameRef'];
+    set busy(val: TableDirectiveElement['busy']);
+    get busy(): TableDirectiveElement['busy'];
+    set busyDelay(val: TableDirectiveElement['busyDelay']);
+    get busyDelay(): TableDirectiveElement['busyDelay'];
+    set growing(val: TableDirectiveElement['growing']);
+    get growing(): TableDirectiveElement['growing'];
+    set growingButtonSubtext(val: TableDirectiveElement['growingButtonSubtext']);
+    get growingButtonSubtext(): TableDirectiveElement['growingButtonSubtext'];
+    set growingButtonText(val: TableDirectiveElement['growingButtonText']);
+    get growingButtonText(): TableDirectiveElement['growingButtonText'];
+    set hideNoData(val: TableDirectiveElement['hideNoData']);
+    get hideNoData(): TableDirectiveElement['hideNoData'];
+    set mode(val: TableDirectiveElement['mode']);
+    get mode(): TableDirectiveElement['mode'];
+    set noDataText(val: TableDirectiveElement['noDataText']);
+    get noDataText(): TableDirectiveElement['noDataText'];
+    set stickyColumnHeader(val: TableDirectiveElement['stickyColumnHeader']);
+    get stickyColumnHeader(): TableDirectiveElement['stickyColumnHeader'];
+    loadMore: Observable<TableDirectiveEventsMap['loadMore']>;
+    popinChange: Observable<TableDirectiveEventsMap['popinChange']>;
+    rowClick: Observable<TableDirectiveEventsMap['rowClick']>;
+    selectionChange: Observable<TableDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<TableDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get columns(): Array<TableColumnDirective['element']>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableDirective, "ui5-table", ["ui5Table"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "busy": "busy"; "busyDelay": "busyDelay"; "growing": "growing"; "growingButtonSubtext": "growingButtonSubtext"; "growingButtonText": "growingButtonText"; "hideNoData": "hideNoData"; "mode": "mode"; "noDataText": "noDataText"; "stickyColumnHeader": "stickyColumnHeader"; }, { "loadMore": "loadMore"; "popinChange": "popinChange"; "rowClick": "rowClick"; "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+export { TableDirective, TableDirectiveEventsMap, TableDirectiveElement };

package/main/directives/text-area.d.ts

@@ -0,0 +1,68 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TextArea.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface TextAreaDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+}
+interface TextAreaDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'growing' | 'growingMaxLines' | 'maxlength' | 'name' | 'placeholder' | 'readonly' | 'required' | 'rows' | 'showExceededText' | 'value' | 'valueState' | 'change' | 'input' | 'valueStateMessage'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    disabled: boolean;
+    growing: boolean;
+    growingMaxLines: any;
+    maxlength: any;
+    name: string;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    rows: any;
+    showExceededText: boolean;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    valueStateMessage: Array<HTMLElement>;
+    addEventListener<K extends keyof TextAreaDirectiveEventsMap>(type: K, listener: (this: TextAreaDirectiveElement, ev: TextAreaDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof TextAreaDirectiveEventsMap>(type: K, listener: (this: TextAreaDirectiveElement, ev: TextAreaDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class TextAreaDirective {
+    private elementRef;
+    set accessibleName(val: TextAreaDirectiveElement['accessibleName']);
+    get accessibleName(): TextAreaDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: TextAreaDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): TextAreaDirectiveElement['accessibleNameRef'];
+    set disabled(val: TextAreaDirectiveElement['disabled']);
+    get disabled(): TextAreaDirectiveElement['disabled'];
+    set growing(val: TextAreaDirectiveElement['growing']);
+    get growing(): TextAreaDirectiveElement['growing'];
+    set growingMaxLines(val: TextAreaDirectiveElement['growingMaxLines']);
+    get growingMaxLines(): TextAreaDirectiveElement['growingMaxLines'];
+    set maxlength(val: TextAreaDirectiveElement['maxlength']);
+    get maxlength(): TextAreaDirectiveElement['maxlength'];
+    set name(val: TextAreaDirectiveElement['name']);
+    get name(): TextAreaDirectiveElement['name'];
+    set placeholder(val: TextAreaDirectiveElement['placeholder']);
+    get placeholder(): TextAreaDirectiveElement['placeholder'];
+    set readonly(val: TextAreaDirectiveElement['readonly']);
+    get readonly(): TextAreaDirectiveElement['readonly'];
+    set required(val: TextAreaDirectiveElement['required']);
+    get required(): TextAreaDirectiveElement['required'];
+    set rows(val: TextAreaDirectiveElement['rows']);
+    get rows(): TextAreaDirectiveElement['rows'];
+    set showExceededText(val: TextAreaDirectiveElement['showExceededText']);
+    get showExceededText(): TextAreaDirectiveElement['showExceededText'];
+    set value(val: TextAreaDirectiveElement['value']);
+    get value(): TextAreaDirectiveElement['value'];
+    set valueState(val: TextAreaDirectiveElement['valueState']);
+    get valueState(): TextAreaDirectiveElement['valueState'];
+    change: Observable<TextAreaDirectiveEventsMap['change']>;
+    input: Observable<TextAreaDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<TextAreaDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextAreaDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextAreaDirective, "ui5-textarea", ["ui5Textarea"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "disabled": "disabled"; "growing": "growing"; "growingMaxLines": "growingMaxLines"; "maxlength": "maxlength"; "name": "name"; "placeholder": "placeholder"; "readonly": "readonly"; "required": "required"; "rows": "rows"; "showExceededText": "showExceededText"; "value": "value"; "valueState": "valueState"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+export { TextAreaDirective, TextAreaDirectiveEventsMap, TextAreaDirectiveElement, };

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

@@ -0,0 +1,64 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/TimePicker.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface TimePickerDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+}
+interface TimePickerDirectiveElement extends Omit<HTMLElement, 'disabled' | 'formatPattern' | 'placeholder' | 'readonly' | 'value' | 'valueState' | 'dateValue' | 'change' | 'input' | 'valueStateMessage'> {
+    disabled: boolean;
+    formatPattern: string;
+    placeholder: string;
+    readonly: boolean;
+    value: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    dateValue: any;
+    valueStateMessage: HTMLElement;
+    addEventListener<K extends keyof TimePickerDirectiveEventsMap>(type: K, listener: (this: TimePickerDirectiveElement, ev: TimePickerDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof TimePickerDirectiveEventsMap>(type: K, listener: (this: TimePickerDirectiveElement, ev: TimePickerDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    openPicker(): any;
+}
+declare class TimePickerDirective {
+    private elementRef;
+    set disabled(val: TimePickerDirectiveElement['disabled']);
+    get disabled(): TimePickerDirectiveElement['disabled'];
+    set formatPattern(val: TimePickerDirectiveElement['formatPattern']);
+    get formatPattern(): TimePickerDirectiveElement['formatPattern'];
+    set placeholder(val: TimePickerDirectiveElement['placeholder']);
+    get placeholder(): TimePickerDirectiveElement['placeholder'];
+    set readonly(val: TimePickerDirectiveElement['readonly']);
+    get readonly(): TimePickerDirectiveElement['readonly'];
+    set value(val: TimePickerDirectiveElement['value']);
+    get value(): TimePickerDirectiveElement['value'];
+    set valueState(val: TimePickerDirectiveElement['valueState']);
+    get valueState(): TimePickerDirectiveElement['valueState'];
+    set dateValue(val: TimePickerDirectiveElement['dateValue']);
+    get dateValue(): TimePickerDirectiveElement['dateValue'];
+    change: Observable<TimePickerDirectiveEventsMap['change']>;
+    input: Observable<TimePickerDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<TimePickerDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): HTMLElement;
+    closePicker(): any;
+    formatValue(date: Record<string, any>): string;
+    isOpen(): boolean;
+    isValid(value: string): boolean;
+    openPicker(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimePickerDirective, "ui5-time-picker", ["ui5TimePicker"], { "disabled": "disabled"; "formatPattern": "formatPattern"; "placeholder": "placeholder"; "readonly": "readonly"; "value": "value"; "valueState": "valueState"; "dateValue": "dateValue"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+declare class TimePickerDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<TimePickerDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimePickerDirectiveCva, "ui5-time-picker", never, {}, {}, never, never, false, never>;
+}
+export { TimePickerDirective, TimePickerDirectiveCva, TimePickerDirectiveEventsMap, TimePickerDirectiveElement, };

package/main/directives/title.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Title.js';
+import * as i0 from "@angular/core";
+interface TitleDirectiveElement extends Omit<HTMLElement, 'level' | 'wrappingType'> {
+    level: 'H1' | 'H2' | 'H3' | 'H4' | 'H5' | 'H6';
+    wrappingType: 'None' | 'Normal';
+}
+declare class TitleDirective {
+    private elementRef;
+    set level(val: TitleDirectiveElement['level']);
+    get level(): TitleDirectiveElement['level'];
+    set wrappingType(val: TitleDirectiveElement['wrappingType']);
+    get wrappingType(): TitleDirectiveElement['wrappingType'];
+    constructor(elementRef: ElementRef<TitleDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TitleDirective, "ui5-title", ["ui5Title"], { "level": "level"; "wrappingType": "wrappingType"; }, {}, never, never, false, never>;
+}
+export { TitleDirective, TitleDirectiveElement };

package/main/directives/toast.d.ts

@@ -0,0 +1,21 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Toast.js';
+import * as i0 from "@angular/core";
+interface ToastDirectiveElement extends Omit<HTMLElement, 'duration' | 'placement'> {
+    duration: any;
+    placement: 'BottomCenter' | 'BottomEnd' | 'BottomStart' | 'MiddleCenter' | 'MiddleEnd' | 'MiddleStart' | 'TopCenter' | 'TopEnd' | 'TopStart';
+    show(): any;
+}
+declare class ToastDirective {
+    private elementRef;
+    set duration(val: ToastDirectiveElement['duration']);
+    get duration(): ToastDirectiveElement['duration'];
+    set placement(val: ToastDirectiveElement['placement']);
+    get placement(): ToastDirectiveElement['placement'];
+    constructor(elementRef: ElementRef<ToastDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    show(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToastDirective, "ui5-toast", ["ui5Toast"], { "duration": "duration"; "placement": "placement"; }, {}, never, never, false, never>;
+}
+export { ToastDirective, ToastDirectiveElement };