@ui5/webcomponents-ngx 0.2.3-rc.1 → 0.2.3-rc.3

package/main/popover/index.d.ts

@@ -1,5 +1,6 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/Popover.js';
+import DOMReference from '@ui5/webcomponents-base/dist/types/DOMReference';
 import type Popover from '@ui5/webcomponents/dist/Popover.js';
 import * as i0 from "@angular/core";
 interface PopoverComponentEventsMap extends Omit<HTMLElementEventMap, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen'> {
@@ -10,7 +11,7 @@ interface PopoverComponentEventsMap extends Omit<HTMLElementEventMap, 'afterClos
     }>;
     beforeOpen: CustomEvent<void>;
 }
-export declare interface PopoverElement extends Partial<Omit<Popover, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen' | 'accessibleName' | 'accessibleNameRef' | 'accessibleRole' | 'initialFocus' | 'open' | 'preventFocusRestore' | 'allowTargetOverlap' | 'headerText' | 'hideArrow' | 'hideBackdrop' | 'horizontalAlign' | 'modal' | 'placementType' | 'verticalAlign'>> {
+export declare interface PopoverElement extends Partial<Omit<Popover, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen' | 'accessibleName' | 'accessibleNameRef' | 'accessibleRole' | 'initialFocus' | 'open' | 'preventFocusRestore' | 'allowTargetOverlap' | 'headerText' | 'hideArrow' | 'hideBackdrop' | 'horizontalAlign' | 'modal' | 'opener' | 'placementType' | 'verticalAlign'>> {
     accessibleName: string;
     accessibleNameRef: string;
     accessibleRole: 'AlertDialog' | 'Dialog' | 'None';
@@ -23,6 +24,7 @@ export declare interface PopoverElement extends Partial<Omit<Popover, 'afterClos
     hideBackdrop: boolean;
     horizontalAlign: 'Center' | 'Left' | 'Right' | 'Stretch';
     modal: boolean;
+    opener: DOMReference;
     placementType: 'Bottom' | 'Left' | 'Right' | 'Top';
     verticalAlign: 'Bottom' | 'Center' | 'Stretch' | 'Top';
     addEventListener<K extends keyof PopoverComponentEventsMap>(type: K, listener: (this: PopoverElement, ev: PopoverComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
@@ -46,6 +48,7 @@ export declare class PopoverComponent {
     hideBackdrop?: PopoverElement['hideBackdrop'];
     horizontalAlign?: PopoverElement['horizontalAlign'];
     modal?: PopoverElement['modal'];
+    opener?: PopoverElement['opener'];
     placementType?: PopoverElement['placementType'];
     verticalAlign?: PopoverElement['verticalAlign'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<PopoverElement>, zone: NgZone);

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

@@ -1,12 +1,14 @@
 import { ElementRef, NgZone, ChangeDetectorRef } from '@angular/core';
 import '@ui5/webcomponents/dist/ProgressIndicator.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
 import type ProgressIndicator from '@ui5/webcomponents/dist/ProgressIndicator.js';
 import * as i0 from "@angular/core";
-export declare interface ProgressIndicatorElement extends Partial<Omit<ProgressIndicator, 'accessibleName' | 'disabled' | 'displayValue' | 'hideValue' | 'valueState'>> {
+export declare interface ProgressIndicatorElement extends Partial<Omit<ProgressIndicator, 'accessibleName' | 'disabled' | 'displayValue' | 'hideValue' | 'value' | 'valueState'>> {
     accessibleName: string;
     disabled: boolean;
     displayValue: string;
     hideValue: boolean;
+    value: Integer;
     valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
 }
 export declare class ProgressIndicatorComponent {
@@ -17,6 +19,7 @@ export declare class ProgressIndicatorComponent {
     disabled?: ProgressIndicatorElement['disabled'];
     displayValue?: ProgressIndicatorElement['displayValue'];
     hideValue?: ProgressIndicatorElement['hideValue'];
+    value?: ProgressIndicatorElement['value'];
     valueState?: ProgressIndicatorElement['valueState'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<ProgressIndicatorElement>, zone: NgZone);
     get element(): ProgressIndicatorElement;

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

@@ -1,17 +1,25 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import { GenericControlValueAccessor } from '@ui5/webcomponents-ngx/generic-cva';
 import '@ui5/webcomponents/dist/RangeSlider.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
+import Float from '@ui5/webcomponents-base/dist/types/Float';
 import type RangeSlider from '@ui5/webcomponents/dist/RangeSlider.js';
 import * as i0 from "@angular/core";
 interface RangeSliderComponentEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
     change: CustomEvent<void>;
     input: CustomEvent<void>;
 }
-export declare interface RangeSliderElement extends Partial<Omit<RangeSlider, 'change' | 'input' | 'accessibleName' | 'disabled' | 'showTickmarks' | 'showTooltip'>> {
+export declare interface RangeSliderElement extends Partial<Omit<RangeSlider, 'change' | 'input' | 'accessibleName' | 'disabled' | 'labelInterval' | 'max' | 'min' | 'showTickmarks' | 'showTooltip' | 'step' | 'endValue' | 'startValue'>> {
     accessibleName: string;
     disabled: boolean;
+    labelInterval: Integer;
+    max: Float;
+    min: Float;
     showTickmarks: boolean;
     showTooltip: boolean;
+    step: Integer;
+    endValue: Float;
+    startValue: Float;
     addEventListener<K extends keyof RangeSliderComponentEventsMap>(type: K, listener: (this: RangeSliderElement, ev: RangeSliderComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof RangeSliderComponentEventsMap>(type: K, listener: (this: RangeSliderElement, ev: RangeSliderComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -23,8 +31,14 @@ export declare class RangeSliderComponent extends GenericControlValueAccessor {
     private zone;
     accessibleName?: RangeSliderElement['accessibleName'];
     disabled?: RangeSliderElement['disabled'];
+    labelInterval?: RangeSliderElement['labelInterval'];
+    max?: RangeSliderElement['max'];
+    min?: RangeSliderElement['min'];
     showTickmarks?: RangeSliderElement['showTickmarks'];
     showTooltip?: RangeSliderElement['showTooltip'];
+    step?: RangeSliderElement['step'];
+    endValue?: RangeSliderElement['endValue'];
+    startValue?: RangeSliderElement['startValue'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<RangeSliderElement>, zone: NgZone);
     get element(): RangeSliderElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<RangeSliderComponent, never>;

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

@@ -1,17 +1,21 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/RatingIndicator.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
+import Float from '@ui5/webcomponents-base/dist/types/Float';
 import type RatingIndicator from '@ui5/webcomponents/dist/RatingIndicator.js';
 import * as i0 from "@angular/core";
 interface RatingIndicatorComponentEventsMap extends Omit<HTMLElementEventMap, 'change'> {
     change: CustomEvent<void>;
 }
-export declare interface RatingIndicatorElement extends Partial<Omit<RatingIndicator, 'change' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'readonly' | 'required' | 'tooltip'>> {
+export declare interface RatingIndicatorElement extends Partial<Omit<RatingIndicator, 'change' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'max' | 'readonly' | 'required' | 'tooltip' | 'value'>> {
     accessibleName: string;
     accessibleNameRef: string;
     disabled: boolean;
+    max: Integer;
     readonly: boolean;
     required: boolean;
     tooltip: string;
+    value: Float;
     addEventListener<K extends keyof RatingIndicatorComponentEventsMap>(type: K, listener: (this: RatingIndicatorElement, ev: RatingIndicatorComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof RatingIndicatorComponentEventsMap>(type: K, listener: (this: RatingIndicatorElement, ev: RatingIndicatorComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -24,9 +28,11 @@ export declare class RatingIndicatorComponent {
     accessibleName?: RatingIndicatorElement['accessibleName'];
     accessibleNameRef?: RatingIndicatorElement['accessibleNameRef'];
     disabled?: RatingIndicatorElement['disabled'];
+    max?: RatingIndicatorElement['max'];
     readonly?: RatingIndicatorElement['readonly'];
     required?: RatingIndicatorElement['required'];
     tooltip?: RatingIndicatorElement['tooltip'];
+    value?: RatingIndicatorElement['value'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<RatingIndicatorElement>, zone: NgZone);
     get element(): RatingIndicatorElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<RatingIndicatorComponent, never>;

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

@@ -1,5 +1,6 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/ResponsivePopover.js';
+import DOMReference from '@ui5/webcomponents-base/dist/types/DOMReference';
 import type ResponsivePopover from '@ui5/webcomponents/dist/ResponsivePopover.js';
 import * as i0 from "@angular/core";
 interface ResponsivePopoverComponentEventsMap extends Omit<HTMLElementEventMap, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen'> {
@@ -10,7 +11,7 @@ interface ResponsivePopoverComponentEventsMap extends Omit<HTMLElementEventMap,
     }>;
     beforeOpen: CustomEvent<void>;
 }
-export declare interface ResponsivePopoverElement extends Partial<Omit<ResponsivePopover, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen' | 'accessibleName' | 'accessibleNameRef' | 'accessibleRole' | 'initialFocus' | 'open' | 'preventFocusRestore' | 'allowTargetOverlap' | 'headerText' | 'hideArrow' | 'hideBackdrop' | 'horizontalAlign' | 'modal' | 'placementType' | 'verticalAlign'>> {
+export declare interface ResponsivePopoverElement extends Partial<Omit<ResponsivePopover, 'afterClose' | 'afterOpen' | 'beforeClose' | 'beforeOpen' | 'accessibleName' | 'accessibleNameRef' | 'accessibleRole' | 'initialFocus' | 'open' | 'preventFocusRestore' | 'allowTargetOverlap' | 'headerText' | 'hideArrow' | 'hideBackdrop' | 'horizontalAlign' | 'modal' | 'opener' | 'placementType' | 'verticalAlign'>> {
     accessibleName: string;
     accessibleNameRef: string;
     accessibleRole: 'AlertDialog' | 'Dialog' | 'None';
@@ -23,6 +24,7 @@ export declare interface ResponsivePopoverElement extends Partial<Omit<Responsiv
     hideBackdrop: boolean;
     horizontalAlign: 'Center' | 'Left' | 'Right' | 'Stretch';
     modal: boolean;
+    opener: DOMReference;
     placementType: 'Bottom' | 'Left' | 'Right' | 'Top';
     verticalAlign: 'Bottom' | 'Center' | 'Stretch' | 'Top';
     addEventListener<K extends keyof ResponsivePopoverComponentEventsMap>(type: K, listener: (this: ResponsivePopoverElement, ev: ResponsivePopoverComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
@@ -46,6 +48,7 @@ export declare class ResponsivePopoverComponent {
     hideBackdrop?: ResponsivePopoverElement['hideBackdrop'];
     horizontalAlign?: ResponsivePopoverElement['horizontalAlign'];
     modal?: ResponsivePopoverElement['modal'];
+    opener?: ResponsivePopoverElement['opener'];
     placementType?: ResponsivePopoverElement['placementType'];
     verticalAlign?: ResponsivePopoverElement['verticalAlign'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<ResponsivePopoverElement>, zone: NgZone);

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

@@ -1,5 +1,6 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/SegmentedButton.js';
+import SegmentedButtonItem from '@ui5/webcomponents/dist/SegmentedButtonItem.js';
 import type SegmentedButton from '@ui5/webcomponents/dist/SegmentedButton.js';
 import * as i0 from "@angular/core";
 interface SegmentedButtonComponentEventsMap extends Omit<HTMLElementEventMap, 'selectionChange'> {
@@ -8,9 +9,11 @@ interface SegmentedButtonComponentEventsMap extends Omit<HTMLElementEventMap, 's
         selectedItems: HTMLElement;
     }>;
 }
-export declare interface SegmentedButtonElement extends Partial<Omit<SegmentedButton, 'selectionChange' | 'accessibleName' | 'mode'>> {
+export declare interface SegmentedButtonElement extends Partial<Omit<SegmentedButton, 'selectionChange' | 'accessibleName' | 'mode' | 'selectedItem' | 'selectedItems'>> {
     accessibleName: string;
     mode: 'MultiSelect' | 'SingleSelect';
+    selectedItem: SegmentedButtonItem;
+    selectedItems: SegmentedButtonItem;
     addEventListener<K extends keyof SegmentedButtonComponentEventsMap>(type: K, listener: (this: SegmentedButtonElement, ev: SegmentedButtonComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof SegmentedButtonComponentEventsMap>(type: K, listener: (this: SegmentedButtonElement, ev: SegmentedButtonComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -22,6 +25,8 @@ export declare class SegmentedButtonComponent {
     private zone;
     accessibleName?: SegmentedButtonElement['accessibleName'];
     mode?: SegmentedButtonElement['mode'];
+    selectedItem?: SegmentedButtonElement['selectedItem'];
+    selectedItems?: SegmentedButtonElement['selectedItems'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<SegmentedButtonElement>, zone: NgZone);
     get element(): SegmentedButtonElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonComponent, never>;

package/main/select/index.d.ts

@@ -1,5 +1,8 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { GenericControlValueAccessor } from '@ui5/webcomponents-ngx/generic-cva';
 import '@ui5/webcomponents/dist/Select.js';
+import DOMReference from '@ui5/webcomponents-base/dist/types/DOMReference';
+import Option from '@ui5/webcomponents/dist/Option.js';
 import type Select from '@ui5/webcomponents/dist/Select.js';
 import * as i0 from "@angular/core";
 interface SelectComponentEventsMap extends Omit<HTMLElementEventMap, 'change' | 'close' | 'liveChange' | 'open'> {
@@ -12,32 +15,38 @@ interface SelectComponentEventsMap extends Omit<HTMLElementEventMap, 'change' |
     }>;
     open: CustomEvent<void>;
 }
-export declare interface SelectElement extends Partial<Omit<Select, 'change' | 'close' | 'liveChange' | 'open' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'name' | 'required' | 'valueState'>> {
+export declare interface SelectElement extends Partial<Omit<Select, 'change' | 'close' | 'liveChange' | 'open' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'menu' | 'name' | 'required' | 'selectedOption' | 'value' | 'valueState'>> {
     accessibleName: string;
     accessibleNameRef: string;
     disabled: boolean;
+    menu: DOMReference;
     name: string;
     required: boolean;
+    selectedOption: Option;
+    value: string;
     valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
     addEventListener<K extends keyof SelectComponentEventsMap>(type: K, listener: (this: SelectElement, ev: SelectComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof SelectComponentEventsMap>(type: K, listener: (this: SelectElement, ev: SelectComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
-export declare class SelectComponent {
+export declare class SelectComponent extends GenericControlValueAccessor {
     private c;
     private elementRef;
     private zone;
     accessibleName?: SelectElement['accessibleName'];
     accessibleNameRef?: SelectElement['accessibleNameRef'];
     disabled?: SelectElement['disabled'];
+    menu?: SelectElement['menu'];
     name?: SelectElement['name'];
     required?: SelectElement['required'];
+    selectedOption?: SelectElement['selectedOption'];
+    value?: SelectElement['value'];
     valueState?: SelectElement['valueState'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<SelectElement>, zone: NgZone);
     get element(): SelectElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "ui5-select", ["ui5Select"], { "effectiveDir": { "alias": "effective-dir"; "required": false; }; "isUi5Element": { "alias": "is-ui-5-element"; "required": false; }; "accessibleName": { "alias": "accessible-name"; "required": false; }; "accessibleNameRef": { "alias": "accessible-name-ref"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "selectedOption": { "alias": "selected-option"; "required": false; }; "valueState": { "alias": "value-state"; "required": false; }; }, { "change": "ui5Change"; "close": "ui5Close"; "liveChange": "ui5LiveChange"; "open": "ui5Open"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "ui5-select", ["ui5Select"], { "effectiveDir": { "alias": "effective-dir"; "required": false; }; "isUi5Element": { "alias": "is-ui-5-element"; "required": false; }; "accessibleName": { "alias": "accessible-name"; "required": false; }; "accessibleNameRef": { "alias": "accessible-name-ref"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "selectedOption": { "alias": "selected-option"; "required": false; }; "value": { "alias": "value"; "required": false; }; "valueState": { "alias": "value-state"; "required": false; }; }, { "change": "ui5Change"; "close": "ui5Close"; "liveChange": "ui5LiveChange"; "open": "ui5Open"; }, never, ["*"], true, never>;
 }
 export declare interface SelectComponent extends Partial<SelectElement> {
     change: EventEmitter<SelectComponentEventsMap['change']>;

package/main/select-menu-option/index.d.ts

@@ -1,25 +1,40 @@
-import { ElementRef, NgZone, ChangeDetectorRef } from '@angular/core';
+import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/SelectMenuOption.js';
 import type SelectMenuOption from '@ui5/webcomponents/dist/SelectMenuOption.js';
 import * as i0 from "@angular/core";
-export declare interface SelectMenuOptionElement extends Partial<Omit<SelectMenuOption, 'displayText' | 'navigated' | 'type' | 'value'>> {
-    displayText: string;
+interface SelectMenuOptionComponentEventsMap extends Omit<HTMLElementEventMap, 'detailClick'> {
+    detailClick: CustomEvent<void>;
+}
+export declare interface SelectMenuOptionElement extends Partial<Omit<SelectMenuOption, 'detailClick' | 'disabled' | 'selected' | 'navigated' | 'type' | 'accessibleName' | 'displayText' | 'value'>> {
+    disabled: boolean;
+    selected: boolean;
     navigated: boolean;
     type: 'Active' | 'Detail' | 'Inactive' | 'Navigation';
+    accessibleName: string;
+    displayText: string;
     value: string;
+    addEventListener<K extends keyof SelectMenuOptionComponentEventsMap>(type: K, listener: (this: SelectMenuOptionElement, ev: SelectMenuOptionComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SelectMenuOptionComponentEventsMap>(type: K, listener: (this: SelectMenuOptionElement, ev: SelectMenuOptionComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 export declare class SelectMenuOptionComponent {
     private c;
     private elementRef;
     private zone;
-    displayText?: SelectMenuOptionElement['displayText'];
+    disabled?: SelectMenuOptionElement['disabled'];
+    selected?: SelectMenuOptionElement['selected'];
     navigated?: SelectMenuOptionElement['navigated'];
     type?: SelectMenuOptionElement['type'];
+    accessibleName?: SelectMenuOptionElement['accessibleName'];
+    displayText?: SelectMenuOptionElement['displayText'];
     value?: SelectMenuOptionElement['value'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<SelectMenuOptionElement>, zone: NgZone);
     get element(): SelectMenuOptionElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectMenuOptionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SelectMenuOptionComponent, "ui5-select-menu-option", ["ui5SelectMenuOption"], { "effectiveDir": { "alias": "effective-dir"; "required": false; }; "isUi5Element": { "alias": "is-ui-5-element"; "required": false; }; "accessibilityAttributes": { "alias": "accessibility-attributes"; "required": false; }; "displayText": { "alias": "display-text"; "required": false; }; "navigated": { "alias": "navigated"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectMenuOptionComponent, "ui5-select-menu-option", ["ui5SelectMenuOption"], { "effectiveDir": { "alias": "effective-dir"; "required": false; }; "isUi5Element": { "alias": "is-ui-5-element"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "accessibilityAttributes": { "alias": "accessibility-attributes"; "required": false; }; "navigated": { "alias": "navigated"; "required": false; }; "type": { "alias": "type"; "required": false; }; "accessibleName": { "alias": "accessible-name"; "required": false; }; "displayText": { "alias": "display-text"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "detailClick": "ui5DetailClick"; }, never, ["*"], true, never>;
 }
 export declare interface SelectMenuOptionComponent extends Partial<SelectMenuOptionElement> {
+    detailClick: EventEmitter<SelectMenuOptionComponentEventsMap['detailClick']>;
 }
+export {};

package/main/slider/index.d.ts

@@ -1,17 +1,24 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import { GenericControlValueAccessor } from '@ui5/webcomponents-ngx/generic-cva';
 import '@ui5/webcomponents/dist/Slider.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
+import Float from '@ui5/webcomponents-base/dist/types/Float';
 import type Slider from '@ui5/webcomponents/dist/Slider.js';
 import * as i0 from "@angular/core";
 interface SliderComponentEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
     change: CustomEvent<void>;
     input: CustomEvent<void>;
 }
-export declare interface SliderElement extends Partial<Omit<Slider, 'change' | 'input' | 'accessibleName' | 'disabled' | 'showTickmarks' | 'showTooltip'>> {
+export declare interface SliderElement extends Partial<Omit<Slider, 'change' | 'input' | 'accessibleName' | 'disabled' | 'labelInterval' | 'max' | 'min' | 'showTickmarks' | 'showTooltip' | 'step' | 'value'>> {
     accessibleName: string;
     disabled: boolean;
+    labelInterval: Integer;
+    max: Float;
+    min: Float;
     showTickmarks: boolean;
     showTooltip: boolean;
+    step: Integer;
+    value: Float;
     addEventListener<K extends keyof SliderComponentEventsMap>(type: K, listener: (this: SliderElement, ev: SliderComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof SliderComponentEventsMap>(type: K, listener: (this: SliderElement, ev: SliderComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -23,8 +30,13 @@ export declare class SliderComponent extends GenericControlValueAccessor {
     private zone;
     accessibleName?: SliderElement['accessibleName'];
     disabled?: SliderElement['disabled'];
+    labelInterval?: SliderElement['labelInterval'];
+    max?: SliderElement['max'];
+    min?: SliderElement['min'];
     showTickmarks?: SliderElement['showTickmarks'];
     showTooltip?: SliderElement['showTooltip'];
+    step?: SliderElement['step'];
+    value?: SliderElement['value'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<SliderElement>, zone: NgZone);
     get element(): SliderElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;

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

@@ -1,35 +1,48 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { GenericControlValueAccessor } from '@ui5/webcomponents-ngx/generic-cva';
 import '@ui5/webcomponents/dist/StepInput.js';
+import Float from '@ui5/webcomponents-base/dist/types/Float';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
 import type StepInput from '@ui5/webcomponents/dist/StepInput.js';
 import * as i0 from "@angular/core";
 interface StepInputComponentEventsMap extends Omit<HTMLElementEventMap, 'change'> {
     change: CustomEvent<void>;
 }
-export declare interface StepInputElement extends Partial<Omit<StepInput, 'change' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'name' | 'placeholder' | 'readonly' | 'required' | 'valueState'>> {
+export declare interface StepInputElement extends Partial<Omit<StepInput, 'change' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'max' | 'min' | 'name' | 'placeholder' | 'readonly' | 'required' | 'step' | 'value' | 'valuePrecision' | 'valueState'>> {
     accessibleName: string;
     accessibleNameRef: string;
     disabled: boolean;
+    max: Float;
+    min: Float;
     name: string;
     placeholder: string;
     readonly: boolean;
     required: boolean;
+    step: Float;
+    value: Float;
+    valuePrecision: Integer;
     valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
     addEventListener<K extends keyof StepInputComponentEventsMap>(type: K, listener: (this: StepInputElement, ev: StepInputComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof StepInputComponentEventsMap>(type: K, listener: (this: StepInputElement, ev: StepInputComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
-export declare class StepInputComponent {
+export declare class StepInputComponent extends GenericControlValueAccessor {
     private c;
     private elementRef;
     private zone;
     accessibleName?: StepInputElement['accessibleName'];
     accessibleNameRef?: StepInputElement['accessibleNameRef'];
     disabled?: StepInputElement['disabled'];
+    max?: StepInputElement['max'];
+    min?: StepInputElement['min'];
     name?: StepInputElement['name'];
     placeholder?: StepInputElement['placeholder'];
     readonly?: StepInputElement['readonly'];
     required?: StepInputElement['required'];
+    step?: StepInputElement['step'];
+    value?: StepInputElement['value'];
+    valuePrecision?: StepInputElement['valuePrecision'];
     valueState?: StepInputElement['valueState'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<StepInputElement>, zone: NgZone);
     get element(): StepInputElement;

package/main/table/index.d.ts

@@ -1,5 +1,6 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/Table.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
 import type Table from '@ui5/webcomponents/dist/Table.js';
 import * as i0 from "@angular/core";
 interface TableComponentEventsMap extends Omit<HTMLElementEventMap, 'loadMore' | 'popinChange' | 'rowClick' | 'selectionChange'> {
@@ -15,10 +16,11 @@ interface TableComponentEventsMap extends Omit<HTMLElementEventMap, 'loadMore' |
         previouslySelectedRows: Array<any>;
     }>;
 }
-export declare interface TableElement extends Partial<Omit<Table, 'loadMore' | 'popinChange' | 'rowClick' | 'selectionChange' | 'accessibleName' | 'accessibleNameRef' | 'busy' | 'growing' | 'growingButtonSubtext' | 'growingButtonText' | 'hideNoData' | 'mode' | 'noDataText' | 'stickyColumnHeader'>> {
+export declare interface TableElement extends Partial<Omit<Table, 'loadMore' | 'popinChange' | 'rowClick' | 'selectionChange' | 'accessibleName' | 'accessibleNameRef' | 'busy' | 'busyDelay' | 'growing' | 'growingButtonSubtext' | 'growingButtonText' | 'hideNoData' | 'mode' | 'noDataText' | 'stickyColumnHeader'>> {
     accessibleName: string;
     accessibleNameRef: string;
     busy: boolean;
+    busyDelay: Integer;
     growing: 'Button' | 'None' | 'Scroll';
     growingButtonSubtext: string;
     growingButtonText: string;
@@ -38,6 +40,7 @@ export declare class TableComponent {
     accessibleName?: TableElement['accessibleName'];
     accessibleNameRef?: TableElement['accessibleNameRef'];
     busy?: TableElement['busy'];
+    busyDelay?: TableElement['busyDelay'];
     growing?: TableElement['growing'];
     growingButtonSubtext?: TableElement['growingButtonSubtext'];
     growingButtonText?: TableElement['growingButtonText'];

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

@@ -1,9 +1,11 @@
 import { ElementRef, NgZone, ChangeDetectorRef } from '@angular/core';
 import '@ui5/webcomponents/dist/TableColumn.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
 import type TableColumn from '@ui5/webcomponents/dist/TableColumn.js';
 import * as i0 from "@angular/core";
-export declare interface TableColumnElement extends Partial<Omit<TableColumn, 'demandPopin' | 'popinText'>> {
+export declare interface TableColumnElement extends Partial<Omit<TableColumn, 'demandPopin' | 'minWidth' | 'popinText'>> {
     demandPopin: boolean;
+    minWidth: Integer;
     popinText: string;
 }
 export declare class TableColumnComponent {
@@ -11,6 +13,7 @@ export declare class TableColumnComponent {
     private elementRef;
     private zone;
     demandPopin?: TableColumnElement['demandPopin'];
+    minWidth?: TableColumnElement['minWidth'];
     popinText?: TableColumnElement['popinText'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<TableColumnElement>, zone: NgZone);
     get element(): TableColumnElement;

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

@@ -1,20 +1,25 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { GenericControlValueAccessor } from '@ui5/webcomponents-ngx/generic-cva';
 import '@ui5/webcomponents/dist/TextArea.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
 import type TextArea from '@ui5/webcomponents/dist/TextArea.js';
 import * as i0 from "@angular/core";
 interface TextAreaComponentEventsMap extends Omit<HTMLElementEventMap, 'change' | 'input'> {
     change: CustomEvent<void>;
     input: CustomEvent<void>;
 }
-export declare interface TextAreaElement extends Partial<Omit<TextArea, 'change' | 'input' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'growing' | 'name' | 'placeholder' | 'readonly' | 'required' | 'showExceededText' | 'value' | 'valueState'>> {
+export declare interface TextAreaElement extends Partial<Omit<TextArea, 'change' | 'input' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'growing' | 'growingMaxLines' | 'maxlength' | 'name' | 'placeholder' | 'readonly' | 'required' | 'rows' | 'showExceededText' | 'value' | 'valueState'>> {
     accessibleName: string;
     accessibleNameRef: string;
     disabled: boolean;
     growing: boolean;
+    growingMaxLines: Integer;
+    maxlength: Integer;
     name: string;
     placeholder: string;
     readonly: boolean;
     required: boolean;
+    rows: Integer;
     showExceededText: boolean;
     value: string;
     valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
@@ -23,7 +28,7 @@ export declare interface TextAreaElement extends Partial<Omit<TextArea, 'change'
     removeEventListener<K extends keyof TextAreaComponentEventsMap>(type: K, listener: (this: TextAreaElement, ev: TextAreaComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
-export declare class TextAreaComponent {
+export declare class TextAreaComponent extends GenericControlValueAccessor {
     private c;
     private elementRef;
     private zone;
@@ -31,10 +36,13 @@ export declare class TextAreaComponent {
     accessibleNameRef?: TextAreaElement['accessibleNameRef'];
     disabled?: TextAreaElement['disabled'];
     growing?: TextAreaElement['growing'];
+    growingMaxLines?: TextAreaElement['growingMaxLines'];
+    maxlength?: TextAreaElement['maxlength'];
     name?: TextAreaElement['name'];
     placeholder?: TextAreaElement['placeholder'];
     readonly?: TextAreaElement['readonly'];
     required?: TextAreaElement['required'];
+    rows?: TextAreaElement['rows'];
     showExceededText?: TextAreaElement['showExceededText'];
     value?: TextAreaElement['value'];
     valueState?: TextAreaElement['valueState'];

package/main/toast/index.d.ts

@@ -1,14 +1,17 @@
 import { ElementRef, NgZone, ChangeDetectorRef } from '@angular/core';
 import '@ui5/webcomponents/dist/Toast.js';
+import Integer from '@ui5/webcomponents-base/dist/types/Integer';
 import type Toast from '@ui5/webcomponents/dist/Toast.js';
 import * as i0 from "@angular/core";
-export declare interface ToastElement extends Partial<Omit<Toast, 'placement'>> {
+export declare interface ToastElement extends Partial<Omit<Toast, 'duration' | 'placement'>> {
+    duration: Integer;
     placement: 'BottomCenter' | 'BottomEnd' | 'BottomStart' | 'MiddleCenter' | 'MiddleEnd' | 'MiddleStart' | 'TopCenter' | 'TopEnd' | 'TopStart';
 }
 export declare class ToastComponent {
     private c;
     private elementRef;
     private zone;
+    duration?: ToastElement['duration'];
     placement?: ToastElement['placement'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<ToastElement>, zone: NgZone);
     get element(): ToastElement;

package/main/toolbar-button/index.d.ts

@@ -1,11 +1,12 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/ToolbarButton.js';
+import CSSSize from '@ui5/webcomponents-base/dist/types/CSSSize';
 import type ToolbarButton from '@ui5/webcomponents/dist/ToolbarButton.js';
 import * as i0 from "@angular/core";
 interface ToolbarButtonComponentEventsMap extends Omit<HTMLElementEventMap, 'click'> {
     click: CustomEvent<void>;
 }
-export declare interface ToolbarButtonElement extends Partial<Omit<ToolbarButton, 'click' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'icon' | 'iconEnd' | 'text' | 'tooltip'>> {
+export declare interface ToolbarButtonElement extends Partial<Omit<ToolbarButton, 'click' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'icon' | 'iconEnd' | 'text' | 'tooltip' | 'width'>> {
     accessibleName: string;
     accessibleNameRef: string;
     disabled: boolean;
@@ -13,6 +14,7 @@ export declare interface ToolbarButtonElement extends Partial<Omit<ToolbarButton
     iconEnd: boolean;
     text: string;
     tooltip: string;
+    width: CSSSize;
     addEventListener<K extends keyof ToolbarButtonComponentEventsMap>(type: K, listener: (this: ToolbarButtonElement, ev: ToolbarButtonComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof ToolbarButtonComponentEventsMap>(type: K, listener: (this: ToolbarButtonElement, ev: ToolbarButtonComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -29,6 +31,7 @@ export declare class ToolbarButtonComponent {
     iconEnd?: ToolbarButtonElement['iconEnd'];
     text?: ToolbarButtonElement['text'];
     tooltip?: ToolbarButtonElement['tooltip'];
+    width?: ToolbarButtonElement['width'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<ToolbarButtonElement>, zone: NgZone);
     get element(): ToolbarButtonElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarButtonComponent, never>;

package/main/toolbar-select/index.d.ts

@@ -1,5 +1,6 @@
 import { ElementRef, NgZone, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import '@ui5/webcomponents/dist/ToolbarSelect.js';
+import CSSSize from '@ui5/webcomponents-base/dist/types/CSSSize';
 import type ToolbarSelect from '@ui5/webcomponents/dist/ToolbarSelect.js';
 import * as i0 from "@angular/core";
 interface ToolbarSelectComponentEventsMap extends Omit<HTMLElementEventMap, 'change' | 'close' | 'open'> {
@@ -9,11 +10,12 @@ interface ToolbarSelectComponentEventsMap extends Omit<HTMLElementEventMap, 'cha
     close: CustomEvent<void>;
     open: CustomEvent<void>;
 }
-export declare interface ToolbarSelectElement extends Partial<Omit<ToolbarSelect, 'change' | 'close' | 'open' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'valueState'>> {
+export declare interface ToolbarSelectElement extends Partial<Omit<ToolbarSelect, 'change' | 'close' | 'open' | 'accessibleName' | 'accessibleNameRef' | 'disabled' | 'valueState' | 'width'>> {
     accessibleName: string;
     accessibleNameRef: string;
     disabled: boolean;
     valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    width: CSSSize;
     addEventListener<K extends keyof ToolbarSelectComponentEventsMap>(type: K, listener: (this: ToolbarSelectElement, ev: ToolbarSelectComponentEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof ToolbarSelectComponentEventsMap>(type: K, listener: (this: ToolbarSelectElement, ev: ToolbarSelectComponentEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -27,6 +29,7 @@ export declare class ToolbarSelectComponent {
     accessibleNameRef?: ToolbarSelectElement['accessibleNameRef'];
     disabled?: ToolbarSelectElement['disabled'];
     valueState?: ToolbarSelectElement['valueState'];
+    width?: ToolbarSelectElement['width'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<ToolbarSelectElement>, zone: NgZone);
     get element(): ToolbarSelectElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarSelectComponent, never>;

package/main/toolbar-spacer/index.d.ts

@@ -1,13 +1,16 @@
 import { ElementRef, NgZone, ChangeDetectorRef } from '@angular/core';
 import '@ui5/webcomponents/dist/ToolbarSpacer.js';
+import CSSSize from '@ui5/webcomponents-base/dist/types/CSSSize';
 import type ToolbarSpacer from '@ui5/webcomponents/dist/ToolbarSpacer.js';
 import * as i0 from "@angular/core";
-export declare interface ToolbarSpacerElement extends Partial<ToolbarSpacer> {
+export declare interface ToolbarSpacerElement extends Partial<Omit<ToolbarSpacer, 'width'>> {
+    width: CSSSize;
 }
 export declare class ToolbarSpacerComponent {
     private c;
     private elementRef;
     private zone;
+    width?: ToolbarSpacerElement['width'];
     constructor(c: ChangeDetectorRef, elementRef: ElementRef<ToolbarSpacerElement>, zone: NgZone);
     get element(): ToolbarSpacerElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarSpacerComponent, never>;