@ui5/webcomponents-ngx 0.0.1-rc.0

package/fiori/directives/bar.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/Bar.js';
+import * as i0 from "@angular/core";
+interface BarDirectiveElement extends Omit<HTMLElement, 'design' | 'endContent' | 'startContent'> {
+    design: 'FloatingFooter' | 'Footer' | 'Header' | 'Subheader';
+    endContent: Array<HTMLElement>;
+    startContent: Array<HTMLElement>;
+}
+declare class BarDirective {
+    private elementRef;
+    set design(val: BarDirectiveElement['design']);
+    get design(): BarDirectiveElement['design'];
+    constructor(elementRef: ElementRef<BarDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get endContent(): Array<HTMLElement>;
+    get startContent(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BarDirective, "ui5-bar", ["ui5Bar"], { "design": "design"; }, {}, never, never, false, never>;
+}
+export { BarDirective, BarDirectiveElement };

package/fiori/directives/barcode-scanner-dialog.d.ts

@@ -0,0 +1,33 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/BarcodeScannerDialog.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface BarcodeScannerDialogDirectiveEventsMap extends Omit<HTMLElementEventMap, 'scanError' | 'scanSuccess'> {
+    scanError: CustomEvent<{
+        message: string;
+    }>;
+    scanSuccess: CustomEvent<{
+        text: string;
+        rawBytes: Record<string, any>;
+    }>;
+}
+interface BarcodeScannerDialogDirectiveElement extends Omit<HTMLElement, 'scanError' | 'scanSuccess'> {
+    addEventListener<K extends keyof BarcodeScannerDialogDirectiveEventsMap>(type: K, listener: (this: BarcodeScannerDialogDirectiveElement, ev: BarcodeScannerDialogDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof BarcodeScannerDialogDirectiveEventsMap>(type: K, listener: (this: BarcodeScannerDialogDirectiveElement, ev: BarcodeScannerDialogDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    close(): any;
+    show(): any;
+}
+declare class BarcodeScannerDialogDirective {
+    private elementRef;
+    scanError: Observable<BarcodeScannerDialogDirectiveEventsMap['scanError']>;
+    scanSuccess: Observable<BarcodeScannerDialogDirectiveEventsMap['scanSuccess']>;
+    constructor(elementRef: ElementRef<BarcodeScannerDialogDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    close(): any;
+    show(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BarcodeScannerDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BarcodeScannerDialogDirective, "ui5-barcode-scanner-dialog", ["ui5BarcodeScannerDialog"], {}, { "scanError": "scanError"; "scanSuccess": "scanSuccess"; }, never, never, false, never>;
+}
+export { BarcodeScannerDialogDirective, BarcodeScannerDialogDirectiveEventsMap, BarcodeScannerDialogDirectiveElement, };

package/fiori/directives/dynamic-side-content.d.ts

@@ -0,0 +1,49 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/DynamicSideContent.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface DynamicSideContentDirectiveEventsMap extends Omit<HTMLElementEventMap, 'layoutChange'> {
+    layoutChange: CustomEvent<{
+        currentBreakpoint: string;
+        previousBreakpoint: string;
+        mainContentVisible: boolean;
+        sideContentVisible: boolean;
+    }>;
+}
+interface DynamicSideContentDirectiveElement extends Omit<HTMLElement, 'equalSplit' | 'hideMainContent' | 'hideSideContent' | 'sideContentFallDown' | 'sideContentPosition' | 'sideContentVisibility' | 'layoutChange' | 'sideContent'> {
+    equalSplit: boolean;
+    hideMainContent: boolean;
+    hideSideContent: boolean;
+    sideContentFallDown: 'BelowL' | 'BelowM' | 'BelowXL' | 'OnMinimumWidth';
+    sideContentPosition: 'End' | 'Start';
+    sideContentVisibility: 'AlwaysShow' | 'NeverShow' | 'ShowAboveL' | 'ShowAboveM' | 'ShowAboveS';
+    sideContent: Array<HTMLElement>;
+    addEventListener<K extends keyof DynamicSideContentDirectiveEventsMap>(type: K, listener: (this: DynamicSideContentDirectiveElement, ev: DynamicSideContentDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof DynamicSideContentDirectiveEventsMap>(type: K, listener: (this: DynamicSideContentDirectiveElement, ev: DynamicSideContentDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    toggleContents(): any;
+}
+declare class DynamicSideContentDirective {
+    private elementRef;
+    set equalSplit(val: DynamicSideContentDirectiveElement['equalSplit']);
+    get equalSplit(): DynamicSideContentDirectiveElement['equalSplit'];
+    set hideMainContent(val: DynamicSideContentDirectiveElement['hideMainContent']);
+    get hideMainContent(): DynamicSideContentDirectiveElement['hideMainContent'];
+    set hideSideContent(val: DynamicSideContentDirectiveElement['hideSideContent']);
+    get hideSideContent(): DynamicSideContentDirectiveElement['hideSideContent'];
+    set sideContentFallDown(val: DynamicSideContentDirectiveElement['sideContentFallDown']);
+    get sideContentFallDown(): DynamicSideContentDirectiveElement['sideContentFallDown'];
+    set sideContentPosition(val: DynamicSideContentDirectiveElement['sideContentPosition']);
+    get sideContentPosition(): DynamicSideContentDirectiveElement['sideContentPosition'];
+    set sideContentVisibility(val: DynamicSideContentDirectiveElement['sideContentVisibility']);
+    get sideContentVisibility(): DynamicSideContentDirectiveElement['sideContentVisibility'];
+    layoutChange: Observable<DynamicSideContentDirectiveEventsMap['layoutChange']>;
+    constructor(elementRef: ElementRef<DynamicSideContentDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get sideContent(): Array<HTMLElement>;
+    toggleContents(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicSideContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicSideContentDirective, "ui5-dynamic-side-content", ["ui5DynamicSideContent"], { "equalSplit": "equalSplit"; "hideMainContent": "hideMainContent"; "hideSideContent": "hideSideContent"; "sideContentFallDown": "sideContentFallDown"; "sideContentPosition": "sideContentPosition"; "sideContentVisibility": "sideContentVisibility"; }, { "layoutChange": "layoutChange"; }, never, never, false, never>;
+}
+export { DynamicSideContentDirective, DynamicSideContentDirectiveEventsMap, DynamicSideContentDirectiveElement, };

package/fiori/directives/filter-item-option.d.ts

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

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

@@ -0,0 +1,19 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/FilterItem.js';
+import { FilterItemOptionDirective } from './filter-item-option';
+import * as i0 from "@angular/core";
+interface FilterItemDirectiveElement extends Omit<HTMLElement, 'text' | 'values'> {
+    text: string;
+    values: Array<FilterItemOptionDirective['element']>;
+}
+declare class FilterItemDirective {
+    private elementRef;
+    set text(val: FilterItemDirectiveElement['text']);
+    get text(): FilterItemDirectiveElement['text'];
+    constructor(elementRef: ElementRef<FilterItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get values(): Array<FilterItemOptionDirective['element']>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FilterItemDirective, "ui5-filter-item", ["ui5FilterItem"], { "text": "text"; }, {}, never, never, false, never>;
+}
+export { FilterItemDirective, FilterItemDirectiveElement };

package/fiori/directives/flexible-column-layout.d.ts

@@ -0,0 +1,63 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/FlexibleColumnLayout.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface FlexibleColumnLayoutDirectiveEventsMap extends Omit<HTMLElementEventMap, 'layoutChange'> {
+    layoutChange: CustomEvent<{
+        layout: 'EndColumnFullScreen' | 'MidColumnFullScreen' | 'OneColumn' | 'ThreeColumnsEndExpanded' | 'ThreeColumnsMidExpanded' | 'ThreeColumnsMidExpandedEndHidden' | 'ThreeColumnsStartExpandedEndHidden' | 'TwoColumnsMidExpanded' | 'TwoColumnsStartExpanded';
+        columnLayout: Array<any>;
+        startColumnVisible: boolean;
+        midColumnVisible: boolean;
+        endColumnVisible: boolean;
+        arrowsUsed: boolean;
+        resize: boolean;
+    }>;
+}
+interface FlexibleColumnLayoutDirectiveElement extends Omit<HTMLElement, 'accessibilityRoles' | 'accessibilityTexts' | 'columnLayout' | 'endColumnVisible' | 'hideArrows' | 'layout' | 'midColumnVisible' | 'startColumnVisible' | 'visibleColumns' | 'layoutChange' | 'endColumn' | 'midColumn' | 'startColumn'> {
+    accessibilityRoles: Record<string, any>;
+    accessibilityTexts: Record<string, any>;
+    columnLayout: Array<any>;
+    endColumnVisible: boolean;
+    hideArrows: boolean;
+    layout: 'EndColumnFullScreen' | 'MidColumnFullScreen' | 'OneColumn' | 'ThreeColumnsEndExpanded' | 'ThreeColumnsMidExpanded' | 'ThreeColumnsMidExpandedEndHidden' | 'ThreeColumnsStartExpandedEndHidden' | 'TwoColumnsMidExpanded' | 'TwoColumnsStartExpanded';
+    midColumnVisible: boolean;
+    startColumnVisible: boolean;
+    visibleColumns: any;
+    endColumn: HTMLElement;
+    midColumn: HTMLElement;
+    startColumn: HTMLElement;
+    addEventListener<K extends keyof FlexibleColumnLayoutDirectiveEventsMap>(type: K, listener: (this: FlexibleColumnLayoutDirectiveElement, ev: FlexibleColumnLayoutDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof FlexibleColumnLayoutDirectiveEventsMap>(type: K, listener: (this: FlexibleColumnLayoutDirectiveElement, ev: FlexibleColumnLayoutDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class FlexibleColumnLayoutDirective {
+    private elementRef;
+    set accessibilityRoles(val: FlexibleColumnLayoutDirectiveElement['accessibilityRoles']);
+    get accessibilityRoles(): FlexibleColumnLayoutDirectiveElement['accessibilityRoles'];
+    set accessibilityTexts(val: FlexibleColumnLayoutDirectiveElement['accessibilityTexts']);
+    get accessibilityTexts(): FlexibleColumnLayoutDirectiveElement['accessibilityTexts'];
+    set columnLayout(val: FlexibleColumnLayoutDirectiveElement['columnLayout']);
+    get columnLayout(): FlexibleColumnLayoutDirectiveElement['columnLayout'];
+    set endColumnVisible(val: FlexibleColumnLayoutDirectiveElement['endColumnVisible']);
+    get endColumnVisible(): FlexibleColumnLayoutDirectiveElement['endColumnVisible'];
+    set hideArrows(val: FlexibleColumnLayoutDirectiveElement['hideArrows']);
+    get hideArrows(): FlexibleColumnLayoutDirectiveElement['hideArrows'];
+    set layout(val: FlexibleColumnLayoutDirectiveElement['layout']);
+    get layout(): FlexibleColumnLayoutDirectiveElement['layout'];
+    set midColumnVisible(val: FlexibleColumnLayoutDirectiveElement['midColumnVisible']);
+    get midColumnVisible(): FlexibleColumnLayoutDirectiveElement['midColumnVisible'];
+    set startColumnVisible(val: FlexibleColumnLayoutDirectiveElement['startColumnVisible']);
+    get startColumnVisible(): FlexibleColumnLayoutDirectiveElement['startColumnVisible'];
+    set visibleColumns(val: FlexibleColumnLayoutDirectiveElement['visibleColumns']);
+    get visibleColumns(): FlexibleColumnLayoutDirectiveElement['visibleColumns'];
+    layoutChange: Observable<FlexibleColumnLayoutDirectiveEventsMap['layoutChange']>;
+    constructor(elementRef: ElementRef<FlexibleColumnLayoutDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get endColumn(): HTMLElement;
+    get midColumn(): HTMLElement;
+    get startColumn(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexibleColumnLayoutDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexibleColumnLayoutDirective, "ui5-flexible-column-layout", ["ui5FlexibleColumnLayout"], { "accessibilityRoles": "accessibilityRoles"; "accessibilityTexts": "accessibilityTexts"; "columnLayout": "columnLayout"; "endColumnVisible": "endColumnVisible"; "hideArrows": "hideArrows"; "layout": "layout"; "midColumnVisible": "midColumnVisible"; "startColumnVisible": "startColumnVisible"; "visibleColumns": "visibleColumns"; }, { "layoutChange": "layoutChange"; }, never, never, false, never>;
+}
+export { FlexibleColumnLayoutDirective, FlexibleColumnLayoutDirectiveEventsMap, FlexibleColumnLayoutDirectiveElement, };

package/fiori/directives/illustrated-message.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/IllustratedMessage.js';
+import * as i0 from "@angular/core";
+interface IllustratedMessageDirectiveElement extends Omit<HTMLElement, 'accessibleNameRef' | 'name' | 'size' | 'subtitleText' | 'titleText' | 'subtitle' | 'title'> {
+    accessibleNameRef: string;
+    name: 'AddColumn' | 'AddPeople' | 'BalloonSky' | 'BeforeSearch' | 'Connection' | 'EmptyCalendar' | 'EmptyList' | 'EmptyPlanningCalendar' | 'ErrorScreen' | 'FilterTable' | 'GroupTable' | 'NoActivities' | 'NoData' | 'NoEntries' | 'NoFilterResults' | 'NoMail' | 'NoMail_v1' | 'NoNotifications' | 'NoSavedItems' | 'NoSavedItems_v1' | 'NoSearchResults' | 'NoTasks' | 'NoTasks_v1' | 'PageNotFound' | 'ReloadScreen' | 'ResizeColumn' | 'SearchEarth' | 'SearchFolder' | 'SimpleBalloon' | 'SimpleBell' | 'SimpleCalendar' | 'SimpleCheckMark' | 'SimpleConnection' | 'SimpleEmptyDoc' | 'SimpleEmptyList' | 'SimpleError' | 'SimpleMagnifier' | 'SimpleMail' | 'SimpleNoSavedItems' | 'SimpleNotFoundMagnifier' | 'SimpleReload' | 'SimpleTask' | 'SleepingBell' | 'SortColumn' | 'SuccessBalloon' | 'SuccessCheckMark' | 'SuccessHighFive' | 'SuccessScreen' | 'Tent' | 'TntChartArea' | 'TntChartArea2' | 'TntChartBar' | 'TntChartBPMNFlow' | 'TntChartBullet' | 'TntChartDoughnut' | 'TntChartFlow' | 'TntChartGantt' | 'TntChartOrg' | 'TntChartPie' | 'TntCodePlaceholder' | 'TntCompany' | 'TntComponents' | 'TntExternalLink' | 'TntFaceID' | 'TntFingerprint' | 'TntLock' | 'TntMission' | 'TntNoApplications' | 'TntNoFlows' | 'TntNoUsers' | 'TntRadar' | 'TntSecrets' | 'TntServices' | 'TntSessionExpired' | 'TntSessionExpiring' | 'TntSuccess' | 'TntSuccessfulAuth' | 'TntSystems' | 'TntTeams' | 'TntTools' | 'TntUnableToLoad' | 'TntUnlock' | 'TntUnsuccessfulAuth' | 'TntUser2' | 'UnableToLoad' | 'UnableToLoadImage' | 'UnableToUpload' | 'UploadCollection';
+    size: 'Auto' | 'Base' | 'Dialog' | 'Scene' | 'Spot';
+    subtitleText: string;
+    titleText: string;
+    subtitle: HTMLElement;
+    title: HTMLElement;
+}
+declare class IllustratedMessageDirective {
+    private elementRef;
+    set accessibleNameRef(val: IllustratedMessageDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): IllustratedMessageDirectiveElement['accessibleNameRef'];
+    set name(val: IllustratedMessageDirectiveElement['name']);
+    get name(): IllustratedMessageDirectiveElement['name'];
+    set size(val: IllustratedMessageDirectiveElement['size']);
+    get size(): IllustratedMessageDirectiveElement['size'];
+    set subtitleText(val: IllustratedMessageDirectiveElement['subtitleText']);
+    get subtitleText(): IllustratedMessageDirectiveElement['subtitleText'];
+    set titleText(val: IllustratedMessageDirectiveElement['titleText']);
+    get titleText(): IllustratedMessageDirectiveElement['titleText'];
+    constructor(elementRef: ElementRef<IllustratedMessageDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get subtitle(): HTMLElement;
+    get title(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IllustratedMessageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IllustratedMessageDirective, "ui5-illustrated-message", ["ui5IllustratedMessage"], { "accessibleNameRef": "accessibleNameRef"; "name": "name"; "size": "size"; "subtitleText": "subtitleText"; "titleText": "titleText"; }, {}, never, never, false, never>;
+}
+export { IllustratedMessageDirective, IllustratedMessageDirectiveElement };

package/fiori/directives/media-gallery-item.d.ts

@@ -0,0 +1,24 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/MediaGalleryItem.js';
+import * as i0 from "@angular/core";
+interface MediaGalleryItemDirectiveElement extends Omit<HTMLElement, 'disabled' | 'layout' | 'selected' | 'thumbnail'> {
+    disabled: boolean;
+    layout: 'Square' | 'Wide';
+    selected: boolean;
+    thumbnail: HTMLElement;
+}
+declare class MediaGalleryItemDirective {
+    private elementRef;
+    set disabled(val: MediaGalleryItemDirectiveElement['disabled']);
+    get disabled(): MediaGalleryItemDirectiveElement['disabled'];
+    set layout(val: MediaGalleryItemDirectiveElement['layout']);
+    get layout(): MediaGalleryItemDirectiveElement['layout'];
+    set selected(val: MediaGalleryItemDirectiveElement['selected']);
+    get selected(): MediaGalleryItemDirectiveElement['selected'];
+    constructor(elementRef: ElementRef<MediaGalleryItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get thumbnail(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaGalleryItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MediaGalleryItemDirective, "ui5-media-gallery-item", ["ui5MediaGalleryItem"], { "disabled": "disabled"; "layout": "layout"; "selected": "selected"; }, {}, never, never, false, never>;
+}
+export { MediaGalleryItemDirective, MediaGalleryItemDirectiveElement };

package/fiori/directives/media-gallery.d.ts

@@ -0,0 +1,43 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/MediaGallery.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface MediaGalleryDirectiveEventsMap extends Omit<HTMLElementEventMap, 'displayAreaClick' | 'overflowClick' | 'selectionChange'> {
+    displayAreaClick: CustomEvent<void>;
+    overflowClick: CustomEvent<void>;
+    selectionChange: CustomEvent<{
+        item: HTMLElement;
+    }>;
+}
+interface MediaGalleryDirectiveElement extends Omit<HTMLElement, 'interactiveDisplayArea' | 'layout' | 'menuHorizontalAlign' | 'menuVerticalAlign' | 'showAllThumbnails' | 'displayAreaClick' | 'overflowClick' | 'selectionChange'> {
+    interactiveDisplayArea: boolean;
+    layout: 'Auto' | 'Horizontal' | 'Vertical';
+    menuHorizontalAlign: 'Left' | 'Right';
+    menuVerticalAlign: 'Bottom' | 'Top';
+    showAllThumbnails: boolean;
+    addEventListener<K extends keyof MediaGalleryDirectiveEventsMap>(type: K, listener: (this: MediaGalleryDirectiveElement, ev: MediaGalleryDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MediaGalleryDirectiveEventsMap>(type: K, listener: (this: MediaGalleryDirectiveElement, ev: MediaGalleryDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class MediaGalleryDirective {
+    private elementRef;
+    set interactiveDisplayArea(val: MediaGalleryDirectiveElement['interactiveDisplayArea']);
+    get interactiveDisplayArea(): MediaGalleryDirectiveElement['interactiveDisplayArea'];
+    set layout(val: MediaGalleryDirectiveElement['layout']);
+    get layout(): MediaGalleryDirectiveElement['layout'];
+    set menuHorizontalAlign(val: MediaGalleryDirectiveElement['menuHorizontalAlign']);
+    get menuHorizontalAlign(): MediaGalleryDirectiveElement['menuHorizontalAlign'];
+    set menuVerticalAlign(val: MediaGalleryDirectiveElement['menuVerticalAlign']);
+    get menuVerticalAlign(): MediaGalleryDirectiveElement['menuVerticalAlign'];
+    set showAllThumbnails(val: MediaGalleryDirectiveElement['showAllThumbnails']);
+    get showAllThumbnails(): MediaGalleryDirectiveElement['showAllThumbnails'];
+    displayAreaClick: Observable<MediaGalleryDirectiveEventsMap['displayAreaClick']>;
+    overflowClick: Observable<MediaGalleryDirectiveEventsMap['overflowClick']>;
+    selectionChange: Observable<MediaGalleryDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<MediaGalleryDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaGalleryDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MediaGalleryDirective, "ui5-media-gallery", ["ui5MediaGallery"], { "interactiveDisplayArea": "interactiveDisplayArea"; "layout": "layout"; "menuHorizontalAlign": "menuHorizontalAlign"; "menuVerticalAlign": "menuVerticalAlign"; "showAllThumbnails": "showAllThumbnails"; }, { "displayAreaClick": "displayAreaClick"; "overflowClick": "overflowClick"; "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+export { MediaGalleryDirective, MediaGalleryDirectiveEventsMap, MediaGalleryDirectiveElement, };

package/fiori/directives/notification-action.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/NotificationAction.js';
+import * as i0 from "@angular/core";
+interface NotificationActionDirectiveElement extends Omit<HTMLElement, 'design' | 'disabled' | 'icon' | 'text'> {
+    design: 'Attention' | 'Default' | 'Emphasized' | 'Negative' | 'Positive' | 'Transparent';
+    disabled: boolean;
+    icon: string;
+    text: string;
+}
+declare class NotificationActionDirective {
+    private elementRef;
+    set design(val: NotificationActionDirectiveElement['design']);
+    get design(): NotificationActionDirectiveElement['design'];
+    set disabled(val: NotificationActionDirectiveElement['disabled']);
+    get disabled(): NotificationActionDirectiveElement['disabled'];
+    set icon(val: NotificationActionDirectiveElement['icon']);
+    get icon(): NotificationActionDirectiveElement['icon'];
+    set text(val: NotificationActionDirectiveElement['text']);
+    get text(): NotificationActionDirectiveElement['text'];
+    constructor(elementRef: ElementRef<NotificationActionDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationActionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationActionDirective, "ui5-notification-action", ["ui5NotificationAction"], { "design": "design"; "disabled": "disabled"; "icon": "icon"; "text": "text"; }, {}, never, never, false, never>;
+}
+export { NotificationActionDirective, NotificationActionDirectiveElement };

package/fiori/directives/notification-list-group-item.d.ts

@@ -0,0 +1,54 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/NotificationListGroupItem.js';
+import { Observable } from 'rxjs';
+import { NotificationActionDirective } from './notification-action';
+import * as i0 from "@angular/core";
+interface NotificationListGroupItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'close' | 'toggle'> {
+    close: CustomEvent<void>;
+    toggle: CustomEvent<void>;
+}
+interface NotificationListGroupItemDirectiveElement extends Omit<HTMLElement, 'selected' | 'busy' | 'busyDelay' | 'priority' | 'read' | 'showClose' | 'titleText' | 'collapsed' | 'showCounter' | 'close' | 'toggle' | 'actions'> {
+    selected: boolean;
+    busy: boolean;
+    busyDelay: any;
+    priority: 'High' | 'Low' | 'Medium' | 'None';
+    read: boolean;
+    showClose: boolean;
+    titleText: string;
+    collapsed: boolean;
+    showCounter: boolean;
+    actions: Array<NotificationActionDirective['element']>;
+    addEventListener<K extends keyof NotificationListGroupItemDirectiveEventsMap>(type: K, listener: (this: NotificationListGroupItemDirectiveElement, ev: NotificationListGroupItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NotificationListGroupItemDirectiveEventsMap>(type: K, listener: (this: NotificationListGroupItemDirectiveElement, ev: NotificationListGroupItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class NotificationListGroupItemDirective {
+    private elementRef;
+    set selected(val: NotificationListGroupItemDirectiveElement['selected']);
+    get selected(): NotificationListGroupItemDirectiveElement['selected'];
+    set busy(val: NotificationListGroupItemDirectiveElement['busy']);
+    get busy(): NotificationListGroupItemDirectiveElement['busy'];
+    set busyDelay(val: NotificationListGroupItemDirectiveElement['busyDelay']);
+    get busyDelay(): NotificationListGroupItemDirectiveElement['busyDelay'];
+    set priority(val: NotificationListGroupItemDirectiveElement['priority']);
+    get priority(): NotificationListGroupItemDirectiveElement['priority'];
+    set read(val: NotificationListGroupItemDirectiveElement['read']);
+    get read(): NotificationListGroupItemDirectiveElement['read'];
+    set showClose(val: NotificationListGroupItemDirectiveElement['showClose']);
+    get showClose(): NotificationListGroupItemDirectiveElement['showClose'];
+    set titleText(val: NotificationListGroupItemDirectiveElement['titleText']);
+    get titleText(): NotificationListGroupItemDirectiveElement['titleText'];
+    set collapsed(val: NotificationListGroupItemDirectiveElement['collapsed']);
+    get collapsed(): NotificationListGroupItemDirectiveElement['collapsed'];
+    set showCounter(val: NotificationListGroupItemDirectiveElement['showCounter']);
+    get showCounter(): NotificationListGroupItemDirectiveElement['showCounter'];
+    close: Observable<NotificationListGroupItemDirectiveEventsMap['close']>;
+    toggle: Observable<NotificationListGroupItemDirectiveEventsMap['toggle']>;
+    constructor(elementRef: ElementRef<NotificationListGroupItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get actions(): Array<NotificationActionDirective['element']>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationListGroupItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationListGroupItemDirective, "ui5-li-notification-group", ["ui5LiNotificationGroup"], { "selected": "selected"; "busy": "busy"; "busyDelay": "busyDelay"; "priority": "priority"; "read": "read"; "showClose": "showClose"; "titleText": "titleText"; "collapsed": "collapsed"; "showCounter": "showCounter"; }, { "close": "close"; "toggle": "toggle"; }, never, never, false, never>;
+}
+export { NotificationListGroupItemDirective, NotificationListGroupItemDirectiveEventsMap, NotificationListGroupItemDirectiveElement, };

package/fiori/directives/notification-list-item-base.d.ts

@@ -0,0 +1,46 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/NotificationListItemBase.js';
+import { Observable } from 'rxjs';
+import { NotificationActionDirective } from './notification-action';
+import * as i0 from "@angular/core";
+interface NotificationListItemBaseDirectiveEventsMap extends Omit<HTMLElementEventMap, 'close'> {
+    close: CustomEvent<void>;
+}
+interface NotificationListItemBaseDirectiveElement extends Omit<HTMLElement, 'selected' | 'busy' | 'busyDelay' | 'priority' | 'read' | 'showClose' | 'titleText' | 'close' | 'actions'> {
+    selected: boolean;
+    busy: boolean;
+    busyDelay: any;
+    priority: 'High' | 'Low' | 'Medium' | 'None';
+    read: boolean;
+    showClose: boolean;
+    titleText: string;
+    actions: Array<NotificationActionDirective['element']>;
+    addEventListener<K extends keyof NotificationListItemBaseDirectiveEventsMap>(type: K, listener: (this: NotificationListItemBaseDirectiveElement, ev: NotificationListItemBaseDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NotificationListItemBaseDirectiveEventsMap>(type: K, listener: (this: NotificationListItemBaseDirectiveElement, ev: NotificationListItemBaseDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class NotificationListItemBaseDirective {
+    private elementRef;
+    set selected(val: NotificationListItemBaseDirectiveElement['selected']);
+    get selected(): NotificationListItemBaseDirectiveElement['selected'];
+    set busy(val: NotificationListItemBaseDirectiveElement['busy']);
+    get busy(): NotificationListItemBaseDirectiveElement['busy'];
+    set busyDelay(val: NotificationListItemBaseDirectiveElement['busyDelay']);
+    get busyDelay(): NotificationListItemBaseDirectiveElement['busyDelay'];
+    set priority(val: NotificationListItemBaseDirectiveElement['priority']);
+    get priority(): NotificationListItemBaseDirectiveElement['priority'];
+    set read(val: NotificationListItemBaseDirectiveElement['read']);
+    get read(): NotificationListItemBaseDirectiveElement['read'];
+    set showClose(val: NotificationListItemBaseDirectiveElement['showClose']);
+    get showClose(): NotificationListItemBaseDirectiveElement['showClose'];
+    set titleText(val: NotificationListItemBaseDirectiveElement['titleText']);
+    get titleText(): NotificationListItemBaseDirectiveElement['titleText'];
+    close: Observable<NotificationListItemBaseDirectiveEventsMap['close']>;
+    constructor(elementRef: ElementRef<NotificationListItemBaseDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get actions(): Array<NotificationActionDirective['element']>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationListItemBaseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationListItemBaseDirective, "ui5-li-notification-group", ["ui5LiNotificationGroup"], { "selected": "selected"; "busy": "busy"; "busyDelay": "busyDelay"; "priority": "priority"; "read": "read"; "showClose": "showClose"; "titleText": "titleText"; }, { "close": "close"; }, never, never, false, never>;
+}
+export { NotificationListItemBaseDirective, NotificationListItemBaseDirectiveEventsMap, NotificationListItemBaseDirectiveElement, };

package/fiori/directives/notification-list-item.d.ts

@@ -0,0 +1,54 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/NotificationListItem.js';
+import { Observable } from 'rxjs';
+import { NotificationActionDirective } from './notification-action';
+import { AvatarDirective } from '../../main/directives/avatar';
+import * as i0 from "@angular/core";
+interface NotificationListItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'close'> {
+    close: CustomEvent<void>;
+}
+interface NotificationListItemDirectiveElement extends Omit<HTMLElement, 'selected' | 'busy' | 'busyDelay' | 'priority' | 'read' | 'showClose' | 'titleText' | 'wrappingType' | 'close' | 'actions' | 'avatar' | 'footnotes'> {
+    selected: boolean;
+    busy: boolean;
+    busyDelay: any;
+    priority: 'High' | 'Low' | 'Medium' | 'None';
+    read: boolean;
+    showClose: boolean;
+    titleText: string;
+    wrappingType: 'None' | 'Normal';
+    actions: Array<NotificationActionDirective['element']>;
+    avatar: AvatarDirective['element'];
+    footnotes: Array<HTMLElement>;
+    addEventListener<K extends keyof NotificationListItemDirectiveEventsMap>(type: K, listener: (this: NotificationListItemDirectiveElement, ev: NotificationListItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NotificationListItemDirectiveEventsMap>(type: K, listener: (this: NotificationListItemDirectiveElement, ev: NotificationListItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class NotificationListItemDirective {
+    private elementRef;
+    set selected(val: NotificationListItemDirectiveElement['selected']);
+    get selected(): NotificationListItemDirectiveElement['selected'];
+    set busy(val: NotificationListItemDirectiveElement['busy']);
+    get busy(): NotificationListItemDirectiveElement['busy'];
+    set busyDelay(val: NotificationListItemDirectiveElement['busyDelay']);
+    get busyDelay(): NotificationListItemDirectiveElement['busyDelay'];
+    set priority(val: NotificationListItemDirectiveElement['priority']);
+    get priority(): NotificationListItemDirectiveElement['priority'];
+    set read(val: NotificationListItemDirectiveElement['read']);
+    get read(): NotificationListItemDirectiveElement['read'];
+    set showClose(val: NotificationListItemDirectiveElement['showClose']);
+    get showClose(): NotificationListItemDirectiveElement['showClose'];
+    set titleText(val: NotificationListItemDirectiveElement['titleText']);
+    get titleText(): NotificationListItemDirectiveElement['titleText'];
+    set wrappingType(val: NotificationListItemDirectiveElement['wrappingType']);
+    get wrappingType(): NotificationListItemDirectiveElement['wrappingType'];
+    close: Observable<NotificationListItemDirectiveEventsMap['close']>;
+    constructor(elementRef: ElementRef<NotificationListItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get actions(): Array<NotificationActionDirective['element']>;
+    get avatar(): AvatarDirective['element'];
+    get footnotes(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationListItemDirective, "ui5-li-notification", ["ui5LiNotification"], { "selected": "selected"; "busy": "busy"; "busyDelay": "busyDelay"; "priority": "priority"; "read": "read"; "showClose": "showClose"; "titleText": "titleText"; "wrappingType": "wrappingType"; }, { "close": "close"; }, never, never, false, never>;
+}
+export { NotificationListItemDirective, NotificationListItemDirectiveEventsMap, NotificationListItemDirectiveElement, };

package/fiori/directives/page.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents-fiori/dist/Page.js';
+import { BarDirective } from './bar';
+import * as i0 from "@angular/core";
+interface PageDirectiveElement extends Omit<HTMLElement, 'backgroundDesign' | 'disableScrolling' | 'floatingFooter' | 'hideFooter' | 'footer' | 'header'> {
+    backgroundDesign: 'List' | 'Solid' | 'Transparent';
+    disableScrolling: boolean;
+    floatingFooter: boolean;
+    hideFooter: boolean;
+    footer: BarDirective['element'];
+    header: BarDirective['element'];
+}
+declare class PageDirective {
+    private elementRef;
+    set backgroundDesign(val: PageDirectiveElement['backgroundDesign']);
+    get backgroundDesign(): PageDirectiveElement['backgroundDesign'];
+    set disableScrolling(val: PageDirectiveElement['disableScrolling']);
+    get disableScrolling(): PageDirectiveElement['disableScrolling'];
+    set floatingFooter(val: PageDirectiveElement['floatingFooter']);
+    get floatingFooter(): PageDirectiveElement['floatingFooter'];
+    set hideFooter(val: PageDirectiveElement['hideFooter']);
+    get hideFooter(): PageDirectiveElement['hideFooter'];
+    constructor(elementRef: ElementRef<PageDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get footer(): BarDirective['element'];
+    get header(): BarDirective['element'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageDirective, "ui5-page", ["ui5Page"], { "backgroundDesign": "backgroundDesign"; "disableScrolling": "disableScrolling"; "floatingFooter": "floatingFooter"; "hideFooter": "hideFooter"; }, {}, never, never, false, never>;
+}
+export { PageDirective, PageDirectiveElement };

package/fiori/directives/product-switch-item.d.ts

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

package/fiori/directives/product-switch.d.ts

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