@ui5/webcomponents-ngx 0.0.1-rc.0

package/main/directives/range-slider.d.ts

@@ -0,0 +1,89 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/RangeSlider.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface RangeSliderDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+}
+interface RangeSliderDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'disabled' | 'labelInterval' | 'max' | 'min' | 'showTickmarks' | 'showTooltip' | 'step' | 'endValue' | 'startValue' | 'change' | 'input'> {
+    accessibleName: string;
+    disabled: boolean;
+    labelInterval: any;
+    max: any;
+    min: any;
+    showTickmarks: boolean;
+    showTooltip: boolean;
+    step: any;
+    endValue: any;
+    startValue: any;
+    addEventListener<K extends keyof RangeSliderDirectiveEventsMap>(type: K, listener: (this: RangeSliderDirectiveElement, ev: RangeSliderDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof RangeSliderDirectiveEventsMap>(type: K, listener: (this: RangeSliderDirectiveElement, ev: RangeSliderDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    clipValue(): any;
+    computedValueFromPageX(): any;
+    focusInnerElement(): any;
+    getPageXValueFromEvent(): any;
+    getSteppedValue(): any;
+    getStoredPropertyState(): any;
+    getValueFromInteraction(): any;
+    handleDownBase(): any;
+    handleUpBase(): any;
+    isCurrentStateOutdated(): any;
+    isPropertyUpdated(): any;
+    storePropertyState(): any;
+    syncUIAndState(): any;
+    updateValue(): any;
+}
+declare class RangeSliderDirective {
+    private elementRef;
+    set accessibleName(val: RangeSliderDirectiveElement['accessibleName']);
+    get accessibleName(): RangeSliderDirectiveElement['accessibleName'];
+    set disabled(val: RangeSliderDirectiveElement['disabled']);
+    get disabled(): RangeSliderDirectiveElement['disabled'];
+    set labelInterval(val: RangeSliderDirectiveElement['labelInterval']);
+    get labelInterval(): RangeSliderDirectiveElement['labelInterval'];
+    set max(val: RangeSliderDirectiveElement['max']);
+    get max(): RangeSliderDirectiveElement['max'];
+    set min(val: RangeSliderDirectiveElement['min']);
+    get min(): RangeSliderDirectiveElement['min'];
+    set showTickmarks(val: RangeSliderDirectiveElement['showTickmarks']);
+    get showTickmarks(): RangeSliderDirectiveElement['showTickmarks'];
+    set showTooltip(val: RangeSliderDirectiveElement['showTooltip']);
+    get showTooltip(): RangeSliderDirectiveElement['showTooltip'];
+    set step(val: RangeSliderDirectiveElement['step']);
+    get step(): RangeSliderDirectiveElement['step'];
+    set endValue(val: RangeSliderDirectiveElement['endValue']);
+    get endValue(): RangeSliderDirectiveElement['endValue'];
+    set startValue(val: RangeSliderDirectiveElement['startValue']);
+    get startValue(): RangeSliderDirectiveElement['startValue'];
+    change: Observable<RangeSliderDirectiveEventsMap['change']>;
+    input: Observable<RangeSliderDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<RangeSliderDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    clipValue(): any;
+    computedValueFromPageX(): any;
+    focusInnerElement(): any;
+    getPageXValueFromEvent(): any;
+    getSteppedValue(): any;
+    getStoredPropertyState(): any;
+    getValueFromInteraction(): any;
+    handleDownBase(): any;
+    handleUpBase(): any;
+    isCurrentStateOutdated(): any;
+    isPropertyUpdated(): any;
+    storePropertyState(): any;
+    syncUIAndState(): any;
+    updateValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeSliderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RangeSliderDirective, "ui5-range-slider", ["ui5RangeSlider"], { "accessibleName": "accessibleName"; "disabled": "disabled"; "labelInterval": "labelInterval"; "max": "max"; "min": "min"; "showTickmarks": "showTickmarks"; "showTooltip": "showTooltip"; "step": "step"; "endValue": "endValue"; "startValue": "startValue"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+declare class RangeSliderDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<RangeSliderDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeSliderDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RangeSliderDirectiveCva, "ui5-range-slider", never, {}, {}, never, never, false, never>;
+}
+export { RangeSliderDirective, RangeSliderDirectiveCva, RangeSliderDirectiveEventsMap, RangeSliderDirectiveElement, };

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

@@ -0,0 +1,37 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/RatingIndicator.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface RatingIndicatorDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<void>;
+}
+interface RatingIndicatorDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'disabled' | 'max' | 'readonly' | 'value' | 'change'> {
+    accessibleName: string;
+    disabled: boolean;
+    max: any;
+    readonly: boolean;
+    value: any;
+    addEventListener<K extends keyof RatingIndicatorDirectiveEventsMap>(type: K, listener: (this: RatingIndicatorDirectiveElement, ev: RatingIndicatorDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof RatingIndicatorDirectiveEventsMap>(type: K, listener: (this: RatingIndicatorDirectiveElement, ev: RatingIndicatorDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class RatingIndicatorDirective {
+    private elementRef;
+    set accessibleName(val: RatingIndicatorDirectiveElement['accessibleName']);
+    get accessibleName(): RatingIndicatorDirectiveElement['accessibleName'];
+    set disabled(val: RatingIndicatorDirectiveElement['disabled']);
+    get disabled(): RatingIndicatorDirectiveElement['disabled'];
+    set max(val: RatingIndicatorDirectiveElement['max']);
+    get max(): RatingIndicatorDirectiveElement['max'];
+    set readonly(val: RatingIndicatorDirectiveElement['readonly']);
+    get readonly(): RatingIndicatorDirectiveElement['readonly'];
+    set value(val: RatingIndicatorDirectiveElement['value']);
+    get value(): RatingIndicatorDirectiveElement['value'];
+    change: Observable<RatingIndicatorDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<RatingIndicatorDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RatingIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RatingIndicatorDirective, "ui5-rating-indicator", ["ui5RatingIndicator"], { "accessibleName": "accessibleName"; "disabled": "disabled"; "max": "max"; "readonly": "readonly"; "value": "value"; }, { "change": "change"; }, never, never, false, never>;
+}
+export { RatingIndicatorDirective, RatingIndicatorDirectiveEventsMap, RatingIndicatorDirectiveElement, };

package/main/directives/responsive-popover.d.ts

@@ -0,0 +1,102 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/ResponsivePopover.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ResponsivePopoverDirectiveEventsMap extends Omit<HTMLElementEventMap, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen'> {
+    afterClose: CustomEvent<void>;
+    afterOpen: CustomEvent<void>;
+    beforeClose: CustomEvent<{
+        escPressed: boolean;
+    }>;
+    beforeOpen: CustomEvent<void>;
+}
+interface ResponsivePopoverDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'initialFocus' | 'open' | 'preventFocusRestore' | 'allowTargetOverlap' | 'headerText' | 'hideArrow' | 'hideBackdrop' | 'horizontalAlign' | 'modal' | 'opener' | 'placementType' | 'verticalAlign' | 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen' | 'footer' | 'header'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    initialFocus: string;
+    open: boolean;
+    preventFocusRestore: boolean;
+    allowTargetOverlap: boolean;
+    headerText: string;
+    hideArrow: boolean;
+    hideBackdrop: boolean;
+    horizontalAlign: 'Center' | 'Left' | 'Right' | 'Stretch';
+    modal: boolean;
+    opener: any;
+    placementType: 'Bottom' | 'Left' | 'Right' | 'Top';
+    verticalAlign: 'Bottom' | 'Center' | 'Stretch' | 'Top';
+    footer: Array<HTMLElement>;
+    header: Array<HTMLElement>;
+    addEventListener<K extends keyof ResponsivePopoverDirectiveEventsMap>(type: K, listener: (this: ResponsivePopoverDirectiveElement, ev: ResponsivePopoverDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ResponsivePopoverDirectiveEventsMap>(type: K, listener: (this: ResponsivePopoverDirectiveElement, ev: ResponsivePopoverDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    _addOpenedPopup(): any;
+    _open(): any;
+    _removeOpenedPopup(): any;
+    _show(): any;
+    applyFocus(): any;
+    applyInitialFocus(): any;
+    blockPageScrolling(): any;
+    close(): any;
+    hide(): any;
+    isOpen(): boolean;
+    resetFocus(): any;
+    unblockPageScrolling(): any;
+    showAt(opener: HTMLElement, preventInitialFocus: boolean): any;
+}
+declare class ResponsivePopoverDirective {
+    private elementRef;
+    set accessibleName(val: ResponsivePopoverDirectiveElement['accessibleName']);
+    get accessibleName(): ResponsivePopoverDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: ResponsivePopoverDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): ResponsivePopoverDirectiveElement['accessibleNameRef'];
+    set initialFocus(val: ResponsivePopoverDirectiveElement['initialFocus']);
+    get initialFocus(): ResponsivePopoverDirectiveElement['initialFocus'];
+    set open(val: ResponsivePopoverDirectiveElement['open']);
+    get open(): ResponsivePopoverDirectiveElement['open'];
+    set preventFocusRestore(val: ResponsivePopoverDirectiveElement['preventFocusRestore']);
+    get preventFocusRestore(): ResponsivePopoverDirectiveElement['preventFocusRestore'];
+    set allowTargetOverlap(val: ResponsivePopoverDirectiveElement['allowTargetOverlap']);
+    get allowTargetOverlap(): ResponsivePopoverDirectiveElement['allowTargetOverlap'];
+    set headerText(val: ResponsivePopoverDirectiveElement['headerText']);
+    get headerText(): ResponsivePopoverDirectiveElement['headerText'];
+    set hideArrow(val: ResponsivePopoverDirectiveElement['hideArrow']);
+    get hideArrow(): ResponsivePopoverDirectiveElement['hideArrow'];
+    set hideBackdrop(val: ResponsivePopoverDirectiveElement['hideBackdrop']);
+    get hideBackdrop(): ResponsivePopoverDirectiveElement['hideBackdrop'];
+    set horizontalAlign(val: ResponsivePopoverDirectiveElement['horizontalAlign']);
+    get horizontalAlign(): ResponsivePopoverDirectiveElement['horizontalAlign'];
+    set modal(val: ResponsivePopoverDirectiveElement['modal']);
+    get modal(): ResponsivePopoverDirectiveElement['modal'];
+    set opener(val: ResponsivePopoverDirectiveElement['opener']);
+    get opener(): ResponsivePopoverDirectiveElement['opener'];
+    set placementType(val: ResponsivePopoverDirectiveElement['placementType']);
+    get placementType(): ResponsivePopoverDirectiveElement['placementType'];
+    set verticalAlign(val: ResponsivePopoverDirectiveElement['verticalAlign']);
+    get verticalAlign(): ResponsivePopoverDirectiveElement['verticalAlign'];
+    afterClose: Observable<ResponsivePopoverDirectiveEventsMap['afterClose']>;
+    afterOpen: Observable<ResponsivePopoverDirectiveEventsMap['afterOpen']>;
+    beforeClose: Observable<ResponsivePopoverDirectiveEventsMap['beforeClose']>;
+    beforeOpen: Observable<ResponsivePopoverDirectiveEventsMap['beforeOpen']>;
+    constructor(elementRef: ElementRef<ResponsivePopoverDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get footer(): Array<HTMLElement>;
+    get header(): Array<HTMLElement>;
+    _addOpenedPopup(): any;
+    _open(): any;
+    _removeOpenedPopup(): any;
+    _show(): any;
+    applyFocus(): any;
+    applyInitialFocus(): any;
+    blockPageScrolling(): any;
+    close(): any;
+    hide(): any;
+    isOpen(): boolean;
+    resetFocus(): any;
+    unblockPageScrolling(): any;
+    showAt(opener: HTMLElement, preventInitialFocus: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsivePopoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResponsivePopoverDirective, "ui5-responsive-popover", ["ui5ResponsivePopover"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "initialFocus": "initialFocus"; "open": "open"; "preventFocusRestore": "preventFocusRestore"; "allowTargetOverlap": "allowTargetOverlap"; "headerText": "headerText"; "hideArrow": "hideArrow"; "hideBackdrop": "hideBackdrop"; "horizontalAlign": "horizontalAlign"; "modal": "modal"; "opener": "opener"; "placementType": "placementType"; "verticalAlign": "verticalAlign"; }, { "afterClose": "afterClose"; "afterOpen": "afterOpen"; "beforeClose": "beforeClose"; "beforeOpen": "beforeOpen"; }, never, never, false, never>;
+}
+export { ResponsivePopoverDirective, ResponsivePopoverDirectiveEventsMap, ResponsivePopoverDirectiveElement, };

package/main/directives/segmented-button-item.d.ts

@@ -0,0 +1,52 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/SegmentedButtonItem.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface SegmentedButtonItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'click'> {
+    click: CustomEvent<void>;
+}
+interface SegmentedButtonItemDirectiveElement extends Omit<HTMLElement, 'accessibilityAttributes' | 'accessibleName' | 'accessibleNameRef' | 'design' | 'disabled' | 'icon' | 'iconEnd' | 'submits' | 'tooltip' | 'pressed' | 'click'> {
+    accessibilityAttributes: Record<string, any>;
+    accessibleName: string;
+    accessibleNameRef: string;
+    design: 'Attention' | 'Default' | 'Emphasized' | 'Negative' | 'Positive' | 'Transparent';
+    disabled: boolean;
+    icon: string;
+    iconEnd: boolean;
+    submits: boolean;
+    tooltip: string;
+    pressed: boolean;
+    addEventListener<K extends keyof SegmentedButtonItemDirectiveEventsMap>(type: K, listener: (this: SegmentedButtonItemDirectiveElement, ev: SegmentedButtonItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SegmentedButtonItemDirectiveEventsMap>(type: K, listener: (this: SegmentedButtonItemDirectiveElement, ev: SegmentedButtonItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class SegmentedButtonItemDirective {
+    private elementRef;
+    set accessibilityAttributes(val: SegmentedButtonItemDirectiveElement['accessibilityAttributes']);
+    get accessibilityAttributes(): SegmentedButtonItemDirectiveElement['accessibilityAttributes'];
+    set accessibleName(val: SegmentedButtonItemDirectiveElement['accessibleName']);
+    get accessibleName(): SegmentedButtonItemDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: SegmentedButtonItemDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): SegmentedButtonItemDirectiveElement['accessibleNameRef'];
+    set design(val: SegmentedButtonItemDirectiveElement['design']);
+    get design(): SegmentedButtonItemDirectiveElement['design'];
+    set disabled(val: SegmentedButtonItemDirectiveElement['disabled']);
+    get disabled(): SegmentedButtonItemDirectiveElement['disabled'];
+    set icon(val: SegmentedButtonItemDirectiveElement['icon']);
+    get icon(): SegmentedButtonItemDirectiveElement['icon'];
+    set iconEnd(val: SegmentedButtonItemDirectiveElement['iconEnd']);
+    get iconEnd(): SegmentedButtonItemDirectiveElement['iconEnd'];
+    set submits(val: SegmentedButtonItemDirectiveElement['submits']);
+    get submits(): SegmentedButtonItemDirectiveElement['submits'];
+    set tooltip(val: SegmentedButtonItemDirectiveElement['tooltip']);
+    get tooltip(): SegmentedButtonItemDirectiveElement['tooltip'];
+    set pressed(val: SegmentedButtonItemDirectiveElement['pressed']);
+    get pressed(): SegmentedButtonItemDirectiveElement['pressed'];
+    click: Observable<SegmentedButtonItemDirectiveEventsMap['click']>;
+    constructor(elementRef: ElementRef<SegmentedButtonItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedButtonItemDirective, "ui5-segmented-button-item", ["ui5SegmentedButtonItem"], { "accessibilityAttributes": "accessibilityAttributes"; "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "design": "design"; "disabled": "disabled"; "icon": "icon"; "iconEnd": "iconEnd"; "submits": "submits"; "tooltip": "tooltip"; "pressed": "pressed"; }, { "click": "click"; }, never, never, false, never>;
+}
+export { SegmentedButtonItemDirective, SegmentedButtonItemDirectiveEventsMap, SegmentedButtonItemDirectiveElement, };

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

@@ -0,0 +1,31 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/SegmentedButton.js';
+import { SegmentedButtonItemDirective } from './segmented-button-item';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface SegmentedButtonDirectiveEventsMap extends Omit<HTMLElementEventMap, 'selectionChange'> {
+    selectionChange: CustomEvent<{
+        selectedItem: HTMLElement;
+    }>;
+}
+interface SegmentedButtonDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'selectedItem' | 'selectionChange'> {
+    accessibleName: string;
+    selectedItem: SegmentedButtonItemDirective['element'];
+    addEventListener<K extends keyof SegmentedButtonDirectiveEventsMap>(type: K, listener: (this: SegmentedButtonDirectiveElement, ev: SegmentedButtonDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SegmentedButtonDirectiveEventsMap>(type: K, listener: (this: SegmentedButtonDirectiveElement, ev: SegmentedButtonDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class SegmentedButtonDirective {
+    private elementRef;
+    set accessibleName(val: SegmentedButtonDirectiveElement['accessibleName']);
+    get accessibleName(): SegmentedButtonDirectiveElement['accessibleName'];
+    set selectedItem(val: SegmentedButtonDirectiveElement['selectedItem']);
+    get selectedItem(): SegmentedButtonDirectiveElement['selectedItem'];
+    selectionChange: Observable<SegmentedButtonDirectiveEventsMap['selectionChange']>;
+    constructor(elementRef: ElementRef<SegmentedButtonDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedButtonDirective, "ui5-segmented-button", ["ui5SegmentedButton"], { "accessibleName": "accessibleName"; "selectedItem": "selectedItem"; }, { "selectionChange": "selectionChange"; }, never, never, false, never>;
+}
+export { SegmentedButtonDirective, SegmentedButtonDirectiveEventsMap, SegmentedButtonDirectiveElement, };

package/main/directives/select.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Select.js';
+import { OptionDirective } from './option';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface SelectDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<{
+        selectedOption: HTMLElement;
+    }>;
+}
+interface SelectDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'name' | 'required' | 'selectedOption' | 'valueState' | 'change' | 'valueStateMessage'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    disabled: boolean;
+    name: string;
+    required: boolean;
+    selectedOption: OptionDirective['element'];
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    valueStateMessage: Array<HTMLElement>;
+    addEventListener<K extends keyof SelectDirectiveEventsMap>(type: K, listener: (this: SelectDirectiveElement, ev: SelectDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SelectDirectiveEventsMap>(type: K, listener: (this: SelectDirectiveElement, ev: SelectDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class SelectDirective {
+    private elementRef;
+    set accessibleName(val: SelectDirectiveElement['accessibleName']);
+    get accessibleName(): SelectDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: SelectDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): SelectDirectiveElement['accessibleNameRef'];
+    set disabled(val: SelectDirectiveElement['disabled']);
+    get disabled(): SelectDirectiveElement['disabled'];
+    set name(val: SelectDirectiveElement['name']);
+    get name(): SelectDirectiveElement['name'];
+    set required(val: SelectDirectiveElement['required']);
+    get required(): SelectDirectiveElement['required'];
+    set selectedOption(val: SelectDirectiveElement['selectedOption']);
+    get selectedOption(): SelectDirectiveElement['selectedOption'];
+    set valueState(val: SelectDirectiveElement['valueState']);
+    get valueState(): SelectDirectiveElement['valueState'];
+    change: Observable<SelectDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<SelectDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get valueStateMessage(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectDirective, "ui5-select", ["ui5Select"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "disabled": "disabled"; "name": "name"; "required": "required"; "selectedOption": "selectedOption"; "valueState": "valueState"; }, { "change": "change"; }, never, never, false, never>;
+}
+export { SelectDirective, SelectDirectiveEventsMap, SelectDirectiveElement };

package/main/directives/slider-base.d.ts

@@ -0,0 +1,76 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/SliderBase.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface SliderBaseDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+}
+interface SliderBaseDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'disabled' | 'labelInterval' | 'max' | 'min' | 'showTickmarks' | 'showTooltip' | 'step' | 'change' | 'input'> {
+    accessibleName: string;
+    disabled: boolean;
+    labelInterval: any;
+    max: any;
+    min: any;
+    showTickmarks: boolean;
+    showTooltip: boolean;
+    step: any;
+    addEventListener<K extends keyof SliderBaseDirectiveEventsMap>(type: K, listener: (this: SliderBaseDirectiveElement, ev: SliderBaseDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SliderBaseDirectiveEventsMap>(type: K, listener: (this: SliderBaseDirectiveElement, ev: SliderBaseDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    clipValue(): any;
+    computedValueFromPageX(): any;
+    focusInnerElement(): any;
+    getPageXValueFromEvent(): any;
+    getSteppedValue(): any;
+    getStoredPropertyState(): any;
+    getValueFromInteraction(): any;
+    handleDownBase(): any;
+    handleUpBase(): any;
+    isCurrentStateOutdated(): any;
+    isPropertyUpdated(): any;
+    storePropertyState(): any;
+    syncUIAndState(): any;
+    updateValue(): any;
+}
+declare class SliderBaseDirective {
+    private elementRef;
+    set accessibleName(val: SliderBaseDirectiveElement['accessibleName']);
+    get accessibleName(): SliderBaseDirectiveElement['accessibleName'];
+    set disabled(val: SliderBaseDirectiveElement['disabled']);
+    get disabled(): SliderBaseDirectiveElement['disabled'];
+    set labelInterval(val: SliderBaseDirectiveElement['labelInterval']);
+    get labelInterval(): SliderBaseDirectiveElement['labelInterval'];
+    set max(val: SliderBaseDirectiveElement['max']);
+    get max(): SliderBaseDirectiveElement['max'];
+    set min(val: SliderBaseDirectiveElement['min']);
+    get min(): SliderBaseDirectiveElement['min'];
+    set showTickmarks(val: SliderBaseDirectiveElement['showTickmarks']);
+    get showTickmarks(): SliderBaseDirectiveElement['showTickmarks'];
+    set showTooltip(val: SliderBaseDirectiveElement['showTooltip']);
+    get showTooltip(): SliderBaseDirectiveElement['showTooltip'];
+    set step(val: SliderBaseDirectiveElement['step']);
+    get step(): SliderBaseDirectiveElement['step'];
+    change: Observable<SliderBaseDirectiveEventsMap['change']>;
+    input: Observable<SliderBaseDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<SliderBaseDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    clipValue(): any;
+    computedValueFromPageX(): any;
+    focusInnerElement(): any;
+    getPageXValueFromEvent(): any;
+    getSteppedValue(): any;
+    getStoredPropertyState(): any;
+    getValueFromInteraction(): any;
+    handleDownBase(): any;
+    handleUpBase(): any;
+    isCurrentStateOutdated(): any;
+    isPropertyUpdated(): any;
+    storePropertyState(): any;
+    syncUIAndState(): any;
+    updateValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderBaseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderBaseDirective, "ui5-slider", ["ui5Slider"], { "accessibleName": "accessibleName"; "disabled": "disabled"; "labelInterval": "labelInterval"; "max": "max"; "min": "min"; "showTickmarks": "showTickmarks"; "showTooltip": "showTooltip"; "step": "step"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+export { SliderBaseDirective, SliderBaseDirectiveEventsMap, SliderBaseDirectiveElement, };

package/main/directives/slider.d.ts

@@ -0,0 +1,86 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Slider.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface SliderDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
+    change: CustomEvent<void>;
+    input: CustomEvent<void>;
+}
+interface SliderDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'disabled' | 'labelInterval' | 'max' | 'min' | 'showTickmarks' | 'showTooltip' | 'step' | 'value' | 'change' | 'input'> {
+    accessibleName: string;
+    disabled: boolean;
+    labelInterval: any;
+    max: any;
+    min: any;
+    showTickmarks: boolean;
+    showTooltip: boolean;
+    step: any;
+    value: any;
+    addEventListener<K extends keyof SliderDirectiveEventsMap>(type: K, listener: (this: SliderDirectiveElement, ev: SliderDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SliderDirectiveEventsMap>(type: K, listener: (this: SliderDirectiveElement, ev: SliderDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    clipValue(): any;
+    computedValueFromPageX(): any;
+    focusInnerElement(): any;
+    getPageXValueFromEvent(): any;
+    getSteppedValue(): any;
+    getStoredPropertyState(): any;
+    getValueFromInteraction(): any;
+    handleDownBase(): any;
+    handleUpBase(): any;
+    isCurrentStateOutdated(): any;
+    isPropertyUpdated(): any;
+    storePropertyState(): any;
+    syncUIAndState(): any;
+    updateValue(): any;
+}
+declare class SliderDirective {
+    private elementRef;
+    set accessibleName(val: SliderDirectiveElement['accessibleName']);
+    get accessibleName(): SliderDirectiveElement['accessibleName'];
+    set disabled(val: SliderDirectiveElement['disabled']);
+    get disabled(): SliderDirectiveElement['disabled'];
+    set labelInterval(val: SliderDirectiveElement['labelInterval']);
+    get labelInterval(): SliderDirectiveElement['labelInterval'];
+    set max(val: SliderDirectiveElement['max']);
+    get max(): SliderDirectiveElement['max'];
+    set min(val: SliderDirectiveElement['min']);
+    get min(): SliderDirectiveElement['min'];
+    set showTickmarks(val: SliderDirectiveElement['showTickmarks']);
+    get showTickmarks(): SliderDirectiveElement['showTickmarks'];
+    set showTooltip(val: SliderDirectiveElement['showTooltip']);
+    get showTooltip(): SliderDirectiveElement['showTooltip'];
+    set step(val: SliderDirectiveElement['step']);
+    get step(): SliderDirectiveElement['step'];
+    set value(val: SliderDirectiveElement['value']);
+    get value(): SliderDirectiveElement['value'];
+    change: Observable<SliderDirectiveEventsMap['change']>;
+    input: Observable<SliderDirectiveEventsMap['input']>;
+    constructor(elementRef: ElementRef<SliderDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    clipValue(): any;
+    computedValueFromPageX(): any;
+    focusInnerElement(): any;
+    getPageXValueFromEvent(): any;
+    getSteppedValue(): any;
+    getStoredPropertyState(): any;
+    getValueFromInteraction(): any;
+    handleDownBase(): any;
+    handleUpBase(): any;
+    isCurrentStateOutdated(): any;
+    isPropertyUpdated(): any;
+    storePropertyState(): any;
+    syncUIAndState(): any;
+    updateValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderDirective, "ui5-slider", ["ui5Slider"], { "accessibleName": "accessibleName"; "disabled": "disabled"; "labelInterval": "labelInterval"; "max": "max"; "min": "min"; "showTickmarks": "showTickmarks"; "showTooltip": "showTooltip"; "step": "step"; "value": "value"; }, { "change": "change"; "input": "input"; }, never, never, false, never>;
+}
+declare class SliderDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<SliderDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderDirectiveCva, "ui5-slider", never, {}, {}, never, never, false, never>;
+}
+export { SliderDirective, SliderDirectiveCva, SliderDirectiveEventsMap, SliderDirectiveElement, };

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

@@ -0,0 +1,39 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/SplitButton.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface SplitButtonDirectiveEventsMap extends Omit<HTMLElementEventMap, 'arrowClick' | 'click'> {
+    arrowClick: CustomEvent<void>;
+    click: CustomEvent<void>;
+}
+interface SplitButtonDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'activeIcon' | 'design' | 'disabled' | 'icon' | 'arrowClick' | 'click'> {
+    accessibleName: string;
+    activeIcon: string;
+    design: 'Attention' | 'Default' | 'Emphasized' | 'Negative' | 'Positive' | 'Transparent';
+    disabled: boolean;
+    icon: string;
+    addEventListener<K extends keyof SplitButtonDirectiveEventsMap>(type: K, listener: (this: SplitButtonDirectiveElement, ev: SplitButtonDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SplitButtonDirectiveEventsMap>(type: K, listener: (this: SplitButtonDirectiveElement, ev: SplitButtonDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class SplitButtonDirective {
+    private elementRef;
+    set accessibleName(val: SplitButtonDirectiveElement['accessibleName']);
+    get accessibleName(): SplitButtonDirectiveElement['accessibleName'];
+    set activeIcon(val: SplitButtonDirectiveElement['activeIcon']);
+    get activeIcon(): SplitButtonDirectiveElement['activeIcon'];
+    set design(val: SplitButtonDirectiveElement['design']);
+    get design(): SplitButtonDirectiveElement['design'];
+    set disabled(val: SplitButtonDirectiveElement['disabled']);
+    get disabled(): SplitButtonDirectiveElement['disabled'];
+    set icon(val: SplitButtonDirectiveElement['icon']);
+    get icon(): SplitButtonDirectiveElement['icon'];
+    arrowClick: Observable<SplitButtonDirectiveEventsMap['arrowClick']>;
+    click: Observable<SplitButtonDirectiveEventsMap['click']>;
+    constructor(elementRef: ElementRef<SplitButtonDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SplitButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SplitButtonDirective, "ui5-split-button", ["ui5SplitButton"], { "accessibleName": "accessibleName"; "activeIcon": "activeIcon"; "design": "design"; "disabled": "disabled"; "icon": "icon"; }, { "arrowClick": "arrowClick"; "click": "click"; }, never, never, false, never>;
+}
+export { SplitButtonDirective, SplitButtonDirectiveEventsMap, SplitButtonDirectiveElement, };

package/main/directives/standard-list-item.d.ts

@@ -0,0 +1,52 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/StandardListItem.js';
+import { Observable } from 'rxjs';
+import { ButtonDirective } from './button';
+import * as i0 from "@angular/core";
+interface StandardListItemDirectiveEventsMap extends Omit<HTMLElementEventMap, 'detailClick'> {
+    detailClick: CustomEvent<void>;
+}
+interface StandardListItemDirectiveElement extends Omit<HTMLElement, 'selected' | 'type' | 'accessibleName' | 'additionalText' | 'additionalTextState' | 'description' | 'icon' | 'iconEnd' | 'image' | 'detailClick' | 'deleteButton'> {
+    selected: boolean;
+    type: 'Active' | 'Detail' | 'Inactive';
+    accessibleName: string;
+    additionalText: string;
+    additionalTextState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    description: string;
+    icon: string;
+    iconEnd: boolean;
+    image: string;
+    deleteButton: ButtonDirective['element'];
+    addEventListener<K extends keyof StandardListItemDirectiveEventsMap>(type: K, listener: (this: StandardListItemDirectiveElement, ev: StandardListItemDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof StandardListItemDirectiveEventsMap>(type: K, listener: (this: StandardListItemDirectiveElement, ev: StandardListItemDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class StandardListItemDirective {
+    private elementRef;
+    set selected(val: StandardListItemDirectiveElement['selected']);
+    get selected(): StandardListItemDirectiveElement['selected'];
+    set type(val: StandardListItemDirectiveElement['type']);
+    get type(): StandardListItemDirectiveElement['type'];
+    set accessibleName(val: StandardListItemDirectiveElement['accessibleName']);
+    get accessibleName(): StandardListItemDirectiveElement['accessibleName'];
+    set additionalText(val: StandardListItemDirectiveElement['additionalText']);
+    get additionalText(): StandardListItemDirectiveElement['additionalText'];
+    set additionalTextState(val: StandardListItemDirectiveElement['additionalTextState']);
+    get additionalTextState(): StandardListItemDirectiveElement['additionalTextState'];
+    set description(val: StandardListItemDirectiveElement['description']);
+    get description(): StandardListItemDirectiveElement['description'];
+    set icon(val: StandardListItemDirectiveElement['icon']);
+    get icon(): StandardListItemDirectiveElement['icon'];
+    set iconEnd(val: StandardListItemDirectiveElement['iconEnd']);
+    get iconEnd(): StandardListItemDirectiveElement['iconEnd'];
+    set image(val: StandardListItemDirectiveElement['image']);
+    get image(): StandardListItemDirectiveElement['image'];
+    detailClick: Observable<StandardListItemDirectiveEventsMap['detailClick']>;
+    constructor(elementRef: ElementRef<StandardListItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get deleteButton(): ButtonDirective['element'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<StandardListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StandardListItemDirective, "ui5-li", ["ui5Li"], { "selected": "selected"; "type": "type"; "accessibleName": "accessibleName"; "additionalText": "additionalText"; "additionalTextState": "additionalTextState"; "description": "description"; "icon": "icon"; "iconEnd": "iconEnd"; "image": "image"; }, { "detailClick": "detailClick"; }, never, never, false, never>;
+}
+export { StandardListItemDirective, StandardListItemDirectiveEventsMap, StandardListItemDirectiveElement, };