@ui5/webcomponents-ngx 0.0.1-rc.0

package/fiori/directives/shell-bar-item.d.ts

@@ -0,0 +1,33 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/ShellBarItem.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ShellBarItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'click'> {
+    click: CustomEvent<{
+        targetRef: HTMLElement;
+    }>;
+}
+interface ShellBarItemDirectiveElement extends Omit<HTMLElement, 'count' | 'icon' | 'text' | 'click'> {
+    count: string;
+    icon: string;
+    text: string;
+    addEventListener<K extends keyof ShellBarItemDirectiveEventsMap>(type: K, listener: (this: ShellBarItemDirectiveElement, ev: ShellBarItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ShellBarItemDirectiveEventsMap>(type: K, listener: (this: ShellBarItemDirectiveElement, ev: ShellBarItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class ShellBarItemDirective {
+    private elementRef;
+    set count(val: ShellBarItemDirectiveElement['count']);
+    get count(): ShellBarItemDirectiveElement['count'];
+    set icon(val: ShellBarItemDirectiveElement['icon']);
+    get icon(): ShellBarItemDirectiveElement['icon'];
+    set text(val: ShellBarItemDirectiveElement['text']);
+    get text(): ShellBarItemDirectiveElement['text'];
+    click: Observable<ShellBarItemDirectiveEventsMap['click']>;
+    constructor(elementRef: ElementRef<ShellBarItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShellBarItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ShellBarItemDirective, "ui5-shellbar-item", ["ui5ShellbarItem"], { "count": "count"; "icon": "icon"; "text": "text"; }, { "click": "click"; }, never, never, false, never>;
+}
+export { ShellBarItemDirective, ShellBarItemDirectiveEventsMap, ShellBarItemDirectiveElement, };

package/fiori/directives/shell-bar.d.ts

@@ -0,0 +1,106 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/ShellBar.js';
+import { Observable } from 'rxjs';
+import { AvatarDirective } from '../../main/directives/avatar';
+import { NotificationListGroupItemDirective } from './notification-list-group-item';
+import { NotificationListItemDirective } from './notification-list-item';
+import { CustomListItemDirective } from '../../main/directives/custom-list-item';
+import { GroupHeaderListItemDirective } from '../../main/directives/group-header-list-item';
+import { StandardListItemDirective } from '../../main/directives/standard-list-item';
+import { InputDirective } from '../../main/directives/input';
+import { ButtonDirective } from '../../main/directives/button';
+import * as i0 from "@angular/core";
+interface ShellBarDirectiveEventsMap extends Omit<HTMLElementEventMap, 'coPilotClick' | 'logoClick' | 'menuItemClick' | 'notificationsClick' | 'productSwitchClick' | 'profileClick'> {
+    coPilotClick: CustomEvent<{
+        targetRef: HTMLElement;
+    }>;
+    logoClick: CustomEvent<{
+        targetRef: HTMLElement;
+    }>;
+    menuItemClick: CustomEvent<{
+        item: HTMLElement;
+    }>;
+    notificationsClick: CustomEvent<{
+        targetRef: HTMLElement;
+    }>;
+    productSwitchClick: CustomEvent<{
+        targetRef: HTMLElement;
+    }>;
+    profileClick: CustomEvent<{
+        targetRef: HTMLElement;
+    }>;
+}
+interface ShellBarDirectiveElement extends Omit<HTMLElement, 'accessibilityRoles' | 'accessibilityTexts' | 'copilotDomRef' | 'logoDomRef' | 'notificationsCount' | 'notificationsDomRef' | 'overflowDomRef' | 'primaryTitle' | 'productSwitchDomRef' | 'profileDomRef' | 'secondaryTitle' | 'showCoPilot' | 'showNotifications' | 'showProductSwitch' | 'coPilotClick' | 'logoClick' | 'menuItemClick' | 'notificationsClick' | 'productSwitchClick' | 'profileClick' | 'logo' | 'menuItems' | 'profile' | 'searchField' | 'startButton'> {
+    accessibilityRoles: Record<string, any>;
+    accessibilityTexts: Record<string, any>;
+    copilotDomRef: HTMLElement;
+    logoDomRef: HTMLElement;
+    notificationsCount: string;
+    notificationsDomRef: HTMLElement;
+    overflowDomRef: HTMLElement;
+    primaryTitle: string;
+    productSwitchDomRef: HTMLElement;
+    profileDomRef: HTMLElement;
+    secondaryTitle: string;
+    showCoPilot: boolean;
+    showNotifications: boolean;
+    showProductSwitch: boolean;
+    logo: AvatarDirective['element'];
+    menuItems: Array<NotificationListGroupItemDirective['element'] | NotificationListItemDirective['element'] | CustomListItemDirective['element'] | GroupHeaderListItemDirective['element'] | StandardListItemDirective['element']>;
+    profile: AvatarDirective['element'];
+    searchField: InputDirective['element'];
+    startButton: ButtonDirective['element'];
+    addEventListener<K extends keyof ShellBarDirectiveEventsMap>(type: K, listener: (this: ShellBarDirectiveElement, ev: ShellBarDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ShellBarDirectiveEventsMap>(type: K, listener: (this: ShellBarDirectiveElement, ev: ShellBarDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    closeOverflow(): any;
+}
+declare class ShellBarDirective {
+    private elementRef;
+    set accessibilityRoles(val: ShellBarDirectiveElement['accessibilityRoles']);
+    get accessibilityRoles(): ShellBarDirectiveElement['accessibilityRoles'];
+    set accessibilityTexts(val: ShellBarDirectiveElement['accessibilityTexts']);
+    get accessibilityTexts(): ShellBarDirectiveElement['accessibilityTexts'];
+    set copilotDomRef(val: ShellBarDirectiveElement['copilotDomRef']);
+    get copilotDomRef(): ShellBarDirectiveElement['copilotDomRef'];
+    set logoDomRef(val: ShellBarDirectiveElement['logoDomRef']);
+    get logoDomRef(): ShellBarDirectiveElement['logoDomRef'];
+    set notificationsCount(val: ShellBarDirectiveElement['notificationsCount']);
+    get notificationsCount(): ShellBarDirectiveElement['notificationsCount'];
+    set notificationsDomRef(val: ShellBarDirectiveElement['notificationsDomRef']);
+    get notificationsDomRef(): ShellBarDirectiveElement['notificationsDomRef'];
+    set overflowDomRef(val: ShellBarDirectiveElement['overflowDomRef']);
+    get overflowDomRef(): ShellBarDirectiveElement['overflowDomRef'];
+    set primaryTitle(val: ShellBarDirectiveElement['primaryTitle']);
+    get primaryTitle(): ShellBarDirectiveElement['primaryTitle'];
+    set productSwitchDomRef(val: ShellBarDirectiveElement['productSwitchDomRef']);
+    get productSwitchDomRef(): ShellBarDirectiveElement['productSwitchDomRef'];
+    set profileDomRef(val: ShellBarDirectiveElement['profileDomRef']);
+    get profileDomRef(): ShellBarDirectiveElement['profileDomRef'];
+    set secondaryTitle(val: ShellBarDirectiveElement['secondaryTitle']);
+    get secondaryTitle(): ShellBarDirectiveElement['secondaryTitle'];
+    set showCoPilot(val: ShellBarDirectiveElement['showCoPilot']);
+    get showCoPilot(): ShellBarDirectiveElement['showCoPilot'];
+    set showNotifications(val: ShellBarDirectiveElement['showNotifications']);
+    get showNotifications(): ShellBarDirectiveElement['showNotifications'];
+    set showProductSwitch(val: ShellBarDirectiveElement['showProductSwitch']);
+    get showProductSwitch(): ShellBarDirectiveElement['showProductSwitch'];
+    coPilotClick: Observable<ShellBarDirectiveEventsMap['coPilotClick']>;
+    logoClick: Observable<ShellBarDirectiveEventsMap['logoClick']>;
+    menuItemClick: Observable<ShellBarDirectiveEventsMap['menuItemClick']>;
+    notificationsClick: Observable<ShellBarDirectiveEventsMap['notificationsClick']>;
+    productSwitchClick: Observable<ShellBarDirectiveEventsMap['productSwitchClick']>;
+    profileClick: Observable<ShellBarDirectiveEventsMap['profileClick']>;
+    constructor(elementRef: ElementRef<ShellBarDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get logo(): AvatarDirective['element'];
+    get menuItems(): Array<NotificationListGroupItemDirective['element'] | NotificationListItemDirective['element'] | CustomListItemDirective['element'] | GroupHeaderListItemDirective['element'] | StandardListItemDirective['element']>;
+    get profile(): AvatarDirective['element'];
+    get searchField(): InputDirective['element'];
+    get startButton(): ButtonDirective['element'];
+    closeOverflow(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShellBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ShellBarDirective, "ui5-shellbar", ["ui5Shellbar"], { "accessibilityRoles": "accessibilityRoles"; "accessibilityTexts": "accessibilityTexts"; "copilotDomRef": "copilotDomRef"; "logoDomRef": "logoDomRef"; "notificationsCount": "notificationsCount"; "notificationsDomRef": "notificationsDomRef"; "overflowDomRef": "overflowDomRef"; "primaryTitle": "primaryTitle"; "productSwitchDomRef": "productSwitchDomRef"; "profileDomRef": "profileDomRef"; "secondaryTitle": "secondaryTitle"; "showCoPilot": "showCoPilot"; "showNotifications": "showNotifications"; "showProductSwitch": "showProductSwitch"; }, { "coPilotClick": "coPilotClick"; "logoClick": "logoClick"; "menuItemClick": "menuItemClick"; "notificationsClick": "notificationsClick"; "productSwitchClick": "productSwitchClick"; "profileClick": "profileClick"; }, never, never, false, never>;
+}
+export { ShellBarDirective, ShellBarDirectiveEventsMap, ShellBarDirectiveElement, };

package/fiori/directives/side-navigation-item.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/SideNavigationItem.js';
+import * as i0 from "@angular/core";
+interface SideNavigationItemDirectiveElement extends Omit<HTMLElement, 'expanded' | 'icon' | 'selected' | 'text' | 'wholeItemToggleable'> {
+    expanded: boolean;
+    icon: string;
+    selected: boolean;
+    text: string;
+    wholeItemToggleable: boolean;
+}
+declare class SideNavigationItemDirective {
+    private elementRef;
+    set expanded(val: SideNavigationItemDirectiveElement['expanded']);
+    get expanded(): SideNavigationItemDirectiveElement['expanded'];
+    set icon(val: SideNavigationItemDirectiveElement['icon']);
+    get icon(): SideNavigationItemDirectiveElement['icon'];
+    set selected(val: SideNavigationItemDirectiveElement['selected']);
+    get selected(): SideNavigationItemDirectiveElement['selected'];
+    set text(val: SideNavigationItemDirectiveElement['text']);
+    get text(): SideNavigationItemDirectiveElement['text'];
+    set wholeItemToggleable(val: SideNavigationItemDirectiveElement['wholeItemToggleable']);
+    get wholeItemToggleable(): SideNavigationItemDirectiveElement['wholeItemToggleable'];
+    constructor(elementRef: ElementRef<SideNavigationItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavigationItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SideNavigationItemDirective, "ui5-side-navigation-item", ["ui5SideNavigationItem"], { "expanded": "expanded"; "icon": "icon"; "selected": "selected"; "text": "text"; "wholeItemToggleable": "wholeItemToggleable"; }, {}, never, never, false, never>;
+}
+export { SideNavigationItemDirective, SideNavigationItemDirectiveElement };

package/fiori/directives/side-navigation-sub-item.d.ts

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

package/fiori/directives/side-navigation.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/SideNavigation.js';
+import { Observable } from 'rxjs';
+import { SideNavigationItemDirective } from './side-navigation-item';
+import * as i0 from "@angular/core";
+interface SideNavigationDirectiveEventsMap extends Omit<HTMLElementEventMap, 'selectionChange'> {
+    selectionChange: CustomEvent<{
+        item: HTMLElement;
+    }>;
+}
+interface SideNavigationDirectiveElement extends Omit<HTMLElement, 'collapsed' | 'selectionChange' | 'fixedItems' | 'header'> {
+    collapsed: boolean;
+    fixedItems: SideNavigationItemDirective['element'];
+    header: Array<HTMLElement>;
+    addEventListener<K extends keyof SideNavigationDirectiveEventsMap>(type: K, listener: (this: SideNavigationDirectiveElement, ev: SideNavigationDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SideNavigationDirectiveEventsMap>(type: K, listener: (this: SideNavigationDirectiveElement, ev: SideNavigationDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class SideNavigationDirective {
+    private elementRef;
+    set collapsed(val: SideNavigationDirectiveElement['collapsed']);
+    get collapsed(): SideNavigationDirectiveElement['collapsed'];
+    selectionChange: Observable<SideNavigationDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<SideNavigationDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get fixedItems(): SideNavigationItemDirective['element'];
+    get header(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavigationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SideNavigationDirective, "ui5-side-navigation", ["ui5SideNavigation"], { "collapsed": "collapsed"; }, { "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+export { SideNavigationDirective, SideNavigationDirectiveEventsMap, SideNavigationDirectiveElement, };

package/fiori/directives/sort-item.d.ts

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

package/fiori/directives/timeline-item.d.ts

@@ -0,0 +1,37 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/TimelineItem.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface TimelineItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'nameClick'> {
+    nameClick: CustomEvent<void>;
+}
+interface TimelineItemDirectiveElement extends Omit<HTMLElement, 'icon' | 'name' | 'nameClickable' | 'subtitleText' | 'titleText' | 'nameClick'> {
+    icon: string;
+    name: string;
+    nameClickable: boolean;
+    subtitleText: string;
+    titleText: string;
+    addEventListener<K extends keyof TimelineItemDirectiveEventsMap>(type: K, listener: (this: TimelineItemDirectiveElement, ev: TimelineItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof TimelineItemDirectiveEventsMap>(type: K, listener: (this: TimelineItemDirectiveElement, ev: TimelineItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class TimelineItemDirective {
+    private elementRef;
+    set icon(val: TimelineItemDirectiveElement['icon']);
+    get icon(): TimelineItemDirectiveElement['icon'];
+    set name(val: TimelineItemDirectiveElement['name']);
+    get name(): TimelineItemDirectiveElement['name'];
+    set nameClickable(val: TimelineItemDirectiveElement['nameClickable']);
+    get nameClickable(): TimelineItemDirectiveElement['nameClickable'];
+    set subtitleText(val: TimelineItemDirectiveElement['subtitleText']);
+    get subtitleText(): TimelineItemDirectiveElement['subtitleText'];
+    set titleText(val: TimelineItemDirectiveElement['titleText']);
+    get titleText(): TimelineItemDirectiveElement['titleText'];
+    nameClick: Observable<TimelineItemDirectiveEventsMap['nameClick']>;
+    constructor(elementRef: ElementRef<TimelineItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimelineItemDirective, "ui5-timeline-item", ["ui5TimelineItem"], { "icon": "icon"; "name": "name"; "nameClickable": "nameClickable"; "subtitleText": "subtitleText"; "titleText": "titleText"; }, { "nameClick": "nameClick"; }, never, never, false, never>;
+}
+export { TimelineItemDirective, TimelineItemDirectiveEventsMap, TimelineItemDirectiveElement, };

package/fiori/directives/timeline.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/Timeline.js';
+import * as i0 from "@angular/core";
+interface TimelineDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'layout'> {
+    accessibleName: string;
+    layout: 'Horizontal' | 'Vertical';
+}
+declare class TimelineDirective {
+    private elementRef;
+    set accessibleName(val: TimelineDirectiveElement['accessibleName']);
+    get accessibleName(): TimelineDirectiveElement['accessibleName'];
+    set layout(val: TimelineDirectiveElement['layout']);
+    get layout(): TimelineDirectiveElement['layout'];
+    constructor(elementRef: ElementRef<TimelineDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimelineDirective, "ui5-timeline", ["ui5Timeline"], { "accessibleName": "accessibleName"; "layout": "layout"; }, {}, never, never, false, never>;
+}
+export { TimelineDirective, TimelineDirectiveElement };

package/fiori/directives/upload-collection-item.d.ts

@@ -0,0 +1,65 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/UploadCollectionItem.js';
+import { Observable } from 'rxjs';
+import { ButtonDirective } from '../../main/directives/button';
+import * as i0 from "@angular/core";
+interface UploadCollectionItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'detailClick' | 'fileNameClick' | 'rename' | 'retry' | 'terminate'> {
+    detailClick: CustomEvent<void>;
+    fileNameClick: CustomEvent<void>;
+    rename: CustomEvent<void>;
+    retry: CustomEvent<void>;
+    terminate: CustomEvent<void>;
+}
+interface UploadCollectionItemDirectiveElement extends Omit<HTMLElement, 'selected' | 'type' | 'disableDeleteButton' | 'file' | 'fileName' | 'fileNameClickable' | 'hideRetryButton' | 'hideTerminateButton' | 'progress' | 'uploadState' | 'detailClick' | 'fileNameClick' | 'rename' | 'retry' | 'terminate' | 'deleteButton' | 'thumbnail'> {
+    selected: boolean;
+    type: 'Active' | 'Detail' | 'Inactive';
+    disableDeleteButton: boolean;
+    file: any;
+    fileName: string;
+    fileNameClickable: boolean;
+    hideRetryButton: boolean;
+    hideTerminateButton: boolean;
+    progress: any;
+    uploadState: 'Complete' | 'Error' | 'Ready' | 'Uploading';
+    deleteButton: ButtonDirective['element'];
+    thumbnail: HTMLElement;
+    addEventListener<K extends keyof UploadCollectionItemDirectiveEventsMap>(type: K, listener: (this: UploadCollectionItemDirectiveElement, ev: UploadCollectionItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof UploadCollectionItemDirectiveEventsMap>(type: K, listener: (this: UploadCollectionItemDirectiveElement, ev: UploadCollectionItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class UploadCollectionItemDirective {
+    private elementRef;
+    set selected(val: UploadCollectionItemDirectiveElement['selected']);
+    get selected(): UploadCollectionItemDirectiveElement['selected'];
+    set type(val: UploadCollectionItemDirectiveElement['type']);
+    get type(): UploadCollectionItemDirectiveElement['type'];
+    set disableDeleteButton(val: UploadCollectionItemDirectiveElement['disableDeleteButton']);
+    get disableDeleteButton(): UploadCollectionItemDirectiveElement['disableDeleteButton'];
+    set file(val: UploadCollectionItemDirectiveElement['file']);
+    get file(): UploadCollectionItemDirectiveElement['file'];
+    set fileName(val: UploadCollectionItemDirectiveElement['fileName']);
+    get fileName(): UploadCollectionItemDirectiveElement['fileName'];
+    set fileNameClickable(val: UploadCollectionItemDirectiveElement['fileNameClickable']);
+    get fileNameClickable(): UploadCollectionItemDirectiveElement['fileNameClickable'];
+    set hideRetryButton(val: UploadCollectionItemDirectiveElement['hideRetryButton']);
+    get hideRetryButton(): UploadCollectionItemDirectiveElement['hideRetryButton'];
+    set hideTerminateButton(val: UploadCollectionItemDirectiveElement['hideTerminateButton']);
+    get hideTerminateButton(): UploadCollectionItemDirectiveElement['hideTerminateButton'];
+    set progress(val: UploadCollectionItemDirectiveElement['progress']);
+    get progress(): UploadCollectionItemDirectiveElement['progress'];
+    set uploadState(val: UploadCollectionItemDirectiveElement['uploadState']);
+    get uploadState(): UploadCollectionItemDirectiveElement['uploadState'];
+    detailClick: Observable<UploadCollectionItemDirectiveEventsMap['detailClick']>;
+    fileNameClick: Observable<UploadCollectionItemDirectiveEventsMap['fileNameClick']>;
+    rename: Observable<UploadCollectionItemDirectiveEventsMap['rename']>;
+    retry: Observable<UploadCollectionItemDirectiveEventsMap['retry']>;
+    terminate: Observable<UploadCollectionItemDirectiveEventsMap['terminate']>;
+    constructor(elementRef: ElementRef<UploadCollectionItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get deleteButton(): ButtonDirective['element'];
+    get thumbnail(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadCollectionItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UploadCollectionItemDirective, "ui5-upload-collection-item", ["ui5UploadCollectionItem"], { "selected": "selected"; "type": "type"; "disableDeleteButton": "disableDeleteButton"; "file": "file"; "fileName": "fileName"; "fileNameClickable": "fileNameClickable"; "hideRetryButton": "hideRetryButton"; "hideTerminateButton": "hideTerminateButton"; "progress": "progress"; "uploadState": "uploadState"; }, { "detailClick": "detailClick"; "fileNameClick": "fileNameClick"; "rename": "rename"; "retry": "retry"; "terminate": "terminate"; }, never, never, false, never>;
+}
+export { UploadCollectionItemDirective, UploadCollectionItemDirectiveEventsMap, UploadCollectionItemDirectiveElement, };

package/fiori/directives/upload-collection.d.ts

@@ -0,0 +1,49 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/UploadCollection.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface UploadCollectionDirectiveEventsMap extends Omit<HTMLElementEventMap, 'drop' | 'itemDelete' | 'selectionChange'> {
+    drop: CustomEvent<{
+        dataTransfer: any;
+    }>;
+    itemDelete: CustomEvent<{
+        item: HTMLElement;
+    }>;
+    selectionChange: CustomEvent<{
+        selectedItems: Array<any>;
+    }>;
+}
+interface UploadCollectionDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'hideDragOverlay' | 'mode' | 'noDataDescription' | 'noDataText' | 'drop' | 'itemDelete' | 'selectionChange' | 'header'> {
+    accessibleName: string;
+    hideDragOverlay: boolean;
+    mode: 'Delete' | 'MultiSelect' | 'None' | 'SingleSelect' | 'SingleSelectAuto' | 'SingleSelectBegin' | 'SingleSelectEnd';
+    noDataDescription: string;
+    noDataText: string;
+    header: Array<HTMLElement>;
+    addEventListener<K extends keyof UploadCollectionDirectiveEventsMap>(type: K, listener: (this: UploadCollectionDirectiveElement, ev: UploadCollectionDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof UploadCollectionDirectiveEventsMap>(type: K, listener: (this: UploadCollectionDirectiveElement, ev: UploadCollectionDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class UploadCollectionDirective {
+    private elementRef;
+    set accessibleName(val: UploadCollectionDirectiveElement['accessibleName']);
+    get accessibleName(): UploadCollectionDirectiveElement['accessibleName'];
+    set hideDragOverlay(val: UploadCollectionDirectiveElement['hideDragOverlay']);
+    get hideDragOverlay(): UploadCollectionDirectiveElement['hideDragOverlay'];
+    set mode(val: UploadCollectionDirectiveElement['mode']);
+    get mode(): UploadCollectionDirectiveElement['mode'];
+    set noDataDescription(val: UploadCollectionDirectiveElement['noDataDescription']);
+    get noDataDescription(): UploadCollectionDirectiveElement['noDataDescription'];
+    set noDataText(val: UploadCollectionDirectiveElement['noDataText']);
+    get noDataText(): UploadCollectionDirectiveElement['noDataText'];
+    drop: Observable<UploadCollectionDirectiveEventsMap['drop']>;
+    itemDelete: Observable<UploadCollectionDirectiveEventsMap['itemDelete']>;
+    selectionChange: Observable<UploadCollectionDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<UploadCollectionDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get header(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadCollectionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UploadCollectionDirective, "ui5-upload-collection", ["ui5UploadCollection"], { "accessibleName": "accessibleName"; "hideDragOverlay": "hideDragOverlay"; "mode": "mode"; "noDataDescription": "noDataDescription"; "noDataText": "noDataText"; }, { "drop": "drop"; "itemDelete": "itemDelete"; "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+export { UploadCollectionDirective, UploadCollectionDirectiveEventsMap, UploadCollectionDirectiveElement, };

package/fiori/directives/view-settings-dialog.d.ts

@@ -0,0 +1,51 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/ViewSettingsDialog.js';
+import { Observable } from 'rxjs';
+import { FilterItemDirective } from './filter-item';
+import { SortItemDirective } from './sort-item';
+import * as i0 from "@angular/core";
+interface ViewSettingsDialogDirectiveEventsMap extends Omit<HTMLElementEventMap, 'beforeOpen' | 'cancel' | 'confirm'> {
+    beforeOpen: CustomEvent<void>;
+    cancel: CustomEvent<{
+        sortOrder: string;
+        sortBy: string;
+        sortByItem: HTMLElement;
+        sortDescending: boolean;
+        filterItems: Array<any>;
+    }>;
+    confirm: CustomEvent<{
+        sortOrder: string;
+        sortBy: string;
+        sortByItem: HTMLElement;
+        sortDescending: boolean;
+        filterItems: Array<any>;
+    }>;
+}
+interface ViewSettingsDialogDirectiveElement extends Omit<HTMLElement, 'sortDescending' | 'beforeOpen' | 'cancel' | 'confirm' | 'filterItems' | 'sortItems'> {
+    sortDescending: boolean;
+    filterItems: Array<FilterItemDirective['element']>;
+    sortItems: Array<SortItemDirective['element']>;
+    addEventListener<K extends keyof ViewSettingsDialogDirectiveEventsMap>(type: K, listener: (this: ViewSettingsDialogDirectiveElement, ev: ViewSettingsDialogDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ViewSettingsDialogDirectiveEventsMap>(type: K, listener: (this: ViewSettingsDialogDirectiveElement, ev: ViewSettingsDialogDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    setConfirmedSettings(settings: Record<string, any>): any;
+    show(): any;
+}
+declare class ViewSettingsDialogDirective {
+    private elementRef;
+    set sortDescending(val: ViewSettingsDialogDirectiveElement['sortDescending']);
+    get sortDescending(): ViewSettingsDialogDirectiveElement['sortDescending'];
+    beforeOpen: Observable<ViewSettingsDialogDirectiveEventsMap['beforeOpen']>;
+    cancel: Observable<ViewSettingsDialogDirectiveEventsMap['cancel']>;
+    confirm: Observable<ViewSettingsDialogDirectiveEventsMap['confirm']>;
+    constructor(elementRef: ElementRef<ViewSettingsDialogDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get filterItems(): Array<FilterItemDirective['element']>;
+    get sortItems(): Array<SortItemDirective['element']>;
+    setConfirmedSettings(settings: Record<string, any>): any;
+    show(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewSettingsDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ViewSettingsDialogDirective, "ui5-view-settings-dialog", ["ui5ViewSettingsDialog"], { "sortDescending": "sortDescending"; }, { "beforeOpen": "beforeOpen"; "cancel": "cancel"; "confirm": "confirm"; }, never, never, false, never>;
+}
+export { ViewSettingsDialogDirective, ViewSettingsDialogDirectiveEventsMap, ViewSettingsDialogDirectiveElement, };

package/fiori/directives/wizard-step.d.ts

@@ -0,0 +1,31 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/WizardStep.js';
+import * as i0 from "@angular/core";
+interface WizardStepDirectiveElement extends Omit<HTMLElement, 'branching' | 'disabled' | 'icon' | 'selected' | 'subtitleText' | 'titleText'> {
+    branching: boolean;
+    disabled: boolean;
+    icon: string;
+    selected: boolean;
+    subtitleText: string;
+    titleText: string;
+}
+declare class WizardStepDirective {
+    private elementRef;
+    set branching(val: WizardStepDirectiveElement['branching']);
+    get branching(): WizardStepDirectiveElement['branching'];
+    set disabled(val: WizardStepDirectiveElement['disabled']);
+    get disabled(): WizardStepDirectiveElement['disabled'];
+    set icon(val: WizardStepDirectiveElement['icon']);
+    get icon(): WizardStepDirectiveElement['icon'];
+    set selected(val: WizardStepDirectiveElement['selected']);
+    get selected(): WizardStepDirectiveElement['selected'];
+    set subtitleText(val: WizardStepDirectiveElement['subtitleText']);
+    get subtitleText(): WizardStepDirectiveElement['subtitleText'];
+    set titleText(val: WizardStepDirectiveElement['titleText']);
+    get titleText(): WizardStepDirectiveElement['titleText'];
+    constructor(elementRef: ElementRef<WizardStepDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WizardStepDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WizardStepDirective, "ui5-wizard-step", ["ui5WizardStep"], { "branching": "branching"; "disabled": "disabled"; "icon": "icon"; "selected": "selected"; "subtitleText": "subtitleText"; "titleText": "titleText"; }, {}, never, never, false, never>;
+}
+export { WizardStepDirective, WizardStepDirectiveElement };

package/fiori/directives/wizard.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/Wizard.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface WizardDirectiveEventsMap extends Omit<HTMLElementEventMap, 'stepChange'> {
+    stepChange: CustomEvent<{
+        step: HTMLElement;
+        previousStep: HTMLElement;
+        changeWithClick: boolean;
+    }>;
+}
+interface WizardDirectiveElement extends Omit<HTMLElement, 'stepChange'> {
+    addEventListener<K extends keyof WizardDirectiveEventsMap>(type: K, listener: (this: WizardDirectiveElement, ev: WizardDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof WizardDirectiveEventsMap>(type: K, listener: (this: WizardDirectiveElement, ev: WizardDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class WizardDirective {
+    private elementRef;
+    stepChange: Observable<WizardDirectiveEventsMap['stepChange']>;
+    constructor(elementRef: ElementRef<WizardDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WizardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WizardDirective, "ui5-wizard", ["ui5Wizard"], {}, { "stepChange": "stepChange"; }, never, never, false, never>;
+}
+export { WizardDirective, WizardDirectiveEventsMap, WizardDirectiveElement };

package/fiori/ui5-fiori.module.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./directives/bar";
+import * as i2 from "./directives/barcode-scanner-dialog";
+import * as i3 from "./directives/dynamic-side-content";
+import * as i4 from "./directives/filter-item";
+import * as i5 from "./directives/filter-item-option";
+import * as i6 from "./directives/flexible-column-layout";
+import * as i7 from "./directives/illustrated-message";
+import * as i8 from "./directives/media-gallery";
+import * as i9 from "./directives/media-gallery-item";
+import * as i10 from "./directives/notification-action";
+import * as i11 from "./directives/notification-list-group-item";
+import * as i12 from "./directives/notification-list-item";
+import * as i13 from "./directives/notification-list-item-base";
+import * as i14 from "./directives/page";
+import * as i15 from "./directives/product-switch";
+import * as i16 from "./directives/product-switch-item";
+import * as i17 from "./directives/shell-bar";
+import * as i18 from "./directives/shell-bar-item";
+import * as i19 from "./directives/side-navigation";
+import * as i20 from "./directives/side-navigation-item";
+import * as i21 from "./directives/side-navigation-sub-item";
+import * as i22 from "./directives/sort-item";
+import * as i23 from "./directives/timeline";
+import * as i24 from "./directives/timeline-item";
+import * as i25 from "./directives/upload-collection";
+import * as i26 from "./directives/upload-collection-item";
+import * as i27 from "./directives/view-settings-dialog";
+import * as i28 from "./directives/wizard";
+import * as i29 from "./directives/wizard-step";
+declare class Ui5FioriModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Ui5FioriModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<Ui5FioriModule, [typeof i1.BarDirective, typeof i2.BarcodeScannerDialogDirective, typeof i3.DynamicSideContentDirective, typeof i4.FilterItemDirective, typeof i5.FilterItemOptionDirective, typeof i6.FlexibleColumnLayoutDirective, typeof i7.IllustratedMessageDirective, typeof i8.MediaGalleryDirective, typeof i9.MediaGalleryItemDirective, typeof i10.NotificationActionDirective, typeof i11.NotificationListGroupItemDirective, typeof i12.NotificationListItemDirective, typeof i13.NotificationListItemBaseDirective, typeof i14.PageDirective, typeof i15.ProductSwitchDirective, typeof i16.ProductSwitchItemDirective, typeof i17.ShellBarDirective, typeof i18.ShellBarItemDirective, typeof i19.SideNavigationDirective, typeof i20.SideNavigationItemDirective, typeof i21.SideNavigationSubItemDirective, typeof i22.SortItemDirective, typeof i23.TimelineDirective, typeof i24.TimelineItemDirective, typeof i25.UploadCollectionDirective, typeof i26.UploadCollectionItemDirective, typeof i27.ViewSettingsDialogDirective, typeof i28.WizardDirective, typeof i29.WizardStepDirective], never, [typeof i1.BarDirective, typeof i2.BarcodeScannerDialogDirective, typeof i3.DynamicSideContentDirective, typeof i4.FilterItemDirective, typeof i5.FilterItemOptionDirective, typeof i6.FlexibleColumnLayoutDirective, typeof i7.IllustratedMessageDirective, typeof i8.MediaGalleryDirective, typeof i9.MediaGalleryItemDirective, typeof i10.NotificationActionDirective, typeof i11.NotificationListGroupItemDirective, typeof i12.NotificationListItemDirective, typeof i13.NotificationListItemBaseDirective, typeof i14.PageDirective, typeof i15.ProductSwitchDirective, typeof i16.ProductSwitchItemDirective, typeof i17.ShellBarDirective, typeof i18.ShellBarItemDirective, typeof i19.SideNavigationDirective, typeof i20.SideNavigationItemDirective, typeof i21.SideNavigationSubItemDirective, typeof i22.SortItemDirective, typeof i23.TimelineDirective, typeof i24.TimelineItemDirective, typeof i25.UploadCollectionDirective, typeof i26.UploadCollectionItemDirective, typeof i27.ViewSettingsDialogDirective, typeof i28.WizardDirective, typeof i29.WizardStepDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<Ui5FioriModule>;
+}
+export { Ui5FioriModule };

package/generic-cva.d.ts

@@ -0,0 +1,27 @@
+import { OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ValueProviderInterface<ValueType = any> {
+    value: ValueType;
+    valueUpdatedNotifier$: Observable<any>;
+    setDisabledState(isDisabled: boolean): void;
+}
+export declare class GenericControlValueAccessor<ValueType = any> implements ControlValueAccessor, OnDestroy {
+    protected host: ValueProviderInterface<ValueType>;
+    onChange: (val: ValueType) => void;
+    onTouched: () => void;
+    private _value?;
+    private _destroy$;
+    private _onChangeSet$;
+    constructor(host: ValueProviderInterface<ValueType>);
+    setDisabledState: (isDisabled: boolean) => void;
+    onChange$: (val: ValueType) => Observable<ValueType>;
+    registerOnChange(fn: (newVal: ValueType) => void): void;
+    registerOnTouched(fn: () => void): void;
+    writeValue(val: ValueType): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericControlValueAccessor<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GenericControlValueAccessor<any>, never, never, {}, {}, never, never, false, never>;
+}
+export {};