@ui5/webcomponents-ngx 0.0.1-rc.0

package/index.d.ts

@@ -0,0 +1,113 @@
+export { BarDirective, BarDirectiveElement } from './fiori/directives/bar';
+export { BarcodeScannerDialogDirective, BarcodeScannerDialogDirectiveEventsMap, BarcodeScannerDialogDirectiveElement, } from './fiori/directives/barcode-scanner-dialog';
+export { DynamicSideContentDirective, DynamicSideContentDirectiveEventsMap, DynamicSideContentDirectiveElement, } from './fiori/directives/dynamic-side-content';
+export { FilterItemDirective, FilterItemDirectiveElement, } from './fiori/directives/filter-item';
+export { FilterItemOptionDirective, FilterItemOptionDirectiveElement, } from './fiori/directives/filter-item-option';
+export { FlexibleColumnLayoutDirective, FlexibleColumnLayoutDirectiveEventsMap, FlexibleColumnLayoutDirectiveElement, } from './fiori/directives/flexible-column-layout';
+export { IllustratedMessageDirective, IllustratedMessageDirectiveElement, } from './fiori/directives/illustrated-message';
+export { MediaGalleryDirective, MediaGalleryDirectiveEventsMap, MediaGalleryDirectiveElement, } from './fiori/directives/media-gallery';
+export { MediaGalleryItemDirective, MediaGalleryItemDirectiveElement, } from './fiori/directives/media-gallery-item';
+export { NotificationActionDirective, NotificationActionDirectiveElement, } from './fiori/directives/notification-action';
+export { NotificationListGroupItemDirective, NotificationListGroupItemDirectiveEventsMap, NotificationListGroupItemDirectiveElement, } from './fiori/directives/notification-list-group-item';
+export { NotificationListItemDirective, NotificationListItemDirectiveEventsMap, NotificationListItemDirectiveElement, } from './fiori/directives/notification-list-item';
+export { NotificationListItemBaseDirective, NotificationListItemBaseDirectiveEventsMap, NotificationListItemBaseDirectiveElement, } from './fiori/directives/notification-list-item-base';
+export { PageDirective, PageDirectiveElement } from './fiori/directives/page';
+export { ProductSwitchDirective, ProductSwitchDirectiveElement, } from './fiori/directives/product-switch';
+export { ProductSwitchItemDirective, ProductSwitchItemDirectiveEventsMap, ProductSwitchItemDirectiveElement, } from './fiori/directives/product-switch-item';
+export { ShellBarDirective, ShellBarDirectiveEventsMap, ShellBarDirectiveElement, } from './fiori/directives/shell-bar';
+export { ShellBarItemDirective, ShellBarItemDirectiveEventsMap, ShellBarItemDirectiveElement, } from './fiori/directives/shell-bar-item';
+export { SideNavigationDirective, SideNavigationDirectiveEventsMap, SideNavigationDirectiveElement, } from './fiori/directives/side-navigation';
+export { SideNavigationItemDirective, SideNavigationItemDirectiveElement, } from './fiori/directives/side-navigation-item';
+export { SideNavigationSubItemDirective, SideNavigationSubItemDirectiveElement, } from './fiori/directives/side-navigation-sub-item';
+export { SortItemDirective, SortItemDirectiveElement, } from './fiori/directives/sort-item';
+export { TimelineDirective, TimelineDirectiveElement, } from './fiori/directives/timeline';
+export { TimelineItemDirective, TimelineItemDirectiveEventsMap, TimelineItemDirectiveElement, } from './fiori/directives/timeline-item';
+export { UploadCollectionDirective, UploadCollectionDirectiveEventsMap, UploadCollectionDirectiveElement, } from './fiori/directives/upload-collection';
+export { UploadCollectionItemDirective, UploadCollectionItemDirectiveEventsMap, UploadCollectionItemDirectiveElement, } from './fiori/directives/upload-collection-item';
+export { ViewSettingsDialogDirective, ViewSettingsDialogDirectiveEventsMap, ViewSettingsDialogDirectiveElement, } from './fiori/directives/view-settings-dialog';
+export { WizardDirective, WizardDirectiveEventsMap, WizardDirectiveElement, } from './fiori/directives/wizard';
+export { WizardStepDirective, WizardStepDirectiveElement, } from './fiori/directives/wizard-step';
+export { AvatarDirective, AvatarDirectiveElement, } from './main/directives/avatar';
+export { AvatarGroupDirective, AvatarGroupDirectiveEventsMap, AvatarGroupDirectiveElement, } from './main/directives/avatar-group';
+export { BadgeDirective, BadgeDirectiveElement } from './main/directives/badge';
+export { BreadcrumbsDirective, BreadcrumbsDirectiveEventsMap, BreadcrumbsDirectiveElement, } from './main/directives/breadcrumbs';
+export { BreadcrumbsItemDirective, BreadcrumbsItemDirectiveElement, } from './main/directives/breadcrumbs-item';
+export { BusyIndicatorDirective, BusyIndicatorDirectiveElement, } from './main/directives/busy-indicator';
+export { ButtonDirective, ButtonDirectiveEventsMap, ButtonDirectiveElement, } from './main/directives/button';
+export { CalendarDirective, CalendarDirectiveEventsMap, CalendarDirectiveElement, } from './main/directives/calendar';
+export { CalendarDateDirective, CalendarDateDirectiveElement, } from './main/directives/calendar-date';
+export { CardDirective, CardDirectiveElement } from './main/directives/card';
+export { CardHeaderDirective, CardHeaderDirectiveEventsMap, CardHeaderDirectiveElement, } from './main/directives/card-header';
+export { CarouselDirective, CarouselDirectiveEventsMap, CarouselDirectiveElement, } from './main/directives/carousel';
+export { CheckBoxDirective, CheckBoxDirectiveCva, CheckBoxDirectiveEventsMap, CheckBoxDirectiveElement, } from './main/directives/check-box';
+export { ColorPaletteDirective, ColorPaletteDirectiveEventsMap, ColorPaletteDirectiveElement, } from './main/directives/color-palette';
+export { ColorPaletteItemDirective, ColorPaletteItemDirectiveElement, } from './main/directives/color-palette-item';
+export { ColorPalettePopoverDirective, ColorPalettePopoverDirectiveEventsMap, ColorPalettePopoverDirectiveElement, } from './main/directives/color-palette-popover';
+export { ColorPickerDirective, ColorPickerDirectiveEventsMap, ColorPickerDirectiveElement, } from './main/directives/color-picker';
+export { ComboBoxDirective, ComboBoxDirectiveCva, ComboBoxDirectiveEventsMap, ComboBoxDirectiveElement, } from './main/directives/combo-box';
+export { ComboBoxGroupItemDirective, ComboBoxGroupItemDirectiveElement, } from './main/directives/combo-box-group-item';
+export { ComboBoxItemDirective, ComboBoxItemDirectiveElement, } from './main/directives/combo-box-item';
+export { CustomListItemDirective, CustomListItemDirectiveEventsMap, CustomListItemDirectiveElement, } from './main/directives/custom-list-item';
+export { DatePickerDirective, DatePickerDirectiveCva, DatePickerDirectiveEventsMap, DatePickerDirectiveElement, } from './main/directives/date-picker';
+export { DateRangePickerDirective, DateRangePickerDirectiveCva, DateRangePickerDirectiveEventsMap, DateRangePickerDirectiveElement, } from './main/directives/date-range-picker';
+export { DateTimePickerDirective, DateTimePickerDirectiveCva, DateTimePickerDirectiveEventsMap, DateTimePickerDirectiveElement, } from './main/directives/date-time-picker';
+export { DayPickerDirective, DayPickerDirectiveEventsMap, DayPickerDirectiveElement, } from './main/directives/day-picker';
+export { DialogDirective, DialogDirectiveEventsMap, DialogDirectiveElement, } from './main/directives/dialog';
+export { FileUploaderDirective, FileUploaderDirectiveCva, FileUploaderDirectiveEventsMap, FileUploaderDirectiveElement, } from './main/directives/file-uploader';
+export { GroupHeaderListItemDirective, GroupHeaderListItemDirectiveElement, } from './main/directives/group-header-list-item';
+export { IconDirective, IconDirectiveElement } from './main/directives/icon';
+export { InputDirective, InputDirectiveCva, InputDirectiveEventsMap, InputDirectiveElement, } from './main/directives/input';
+export { LabelDirective, LabelDirectiveElement } from './main/directives/label';
+export { LinkDirective, LinkDirectiveEventsMap, LinkDirectiveElement, } from './main/directives/link';
+export { ListDirective, ListDirectiveEventsMap, ListDirectiveElement, } from './main/directives/list';
+export { MenuDirective, MenuDirectiveEventsMap, MenuDirectiveElement, } from './main/directives/menu';
+export { MenuItemDirective, MenuItemDirectiveElement, } from './main/directives/menu-item';
+export { MessageStripDirective, MessageStripDirectiveEventsMap, MessageStripDirectiveElement, } from './main/directives/message-strip';
+export { MonthPickerDirective, MonthPickerDirectiveEventsMap, MonthPickerDirectiveElement, } from './main/directives/month-picker';
+export { MultiComboBoxDirective, MultiComboBoxDirectiveCva, MultiComboBoxDirectiveEventsMap, MultiComboBoxDirectiveElement, } from './main/directives/multi-combo-box';
+export { MultiComboBoxGroupItemDirective, MultiComboBoxGroupItemDirectiveElement, } from './main/directives/multi-combo-box-group-item';
+export { MultiComboBoxItemDirective, MultiComboBoxItemDirectiveElement, } from './main/directives/multi-combo-box-item';
+export { MultiInputDirective, MultiInputDirectiveCva, MultiInputDirectiveEventsMap, MultiInputDirectiveElement, } from './main/directives/multi-input';
+export { OptionDirective, OptionDirectiveElement, } from './main/directives/option';
+export { PanelDirective, PanelDirectiveEventsMap, PanelDirectiveElement, } from './main/directives/panel';
+export { PopoverDirective, PopoverDirectiveEventsMap, PopoverDirectiveElement, } from './main/directives/popover';
+export { ProgressIndicatorDirective, ProgressIndicatorDirectiveElement, } from './main/directives/progress-indicator';
+export { RadioButtonDirective, RadioButtonDirectiveCva, RadioButtonDirectiveEventsMap, RadioButtonDirectiveElement, } from './main/directives/radio-button';
+export { RangeSliderDirective, RangeSliderDirectiveCva, RangeSliderDirectiveEventsMap, RangeSliderDirectiveElement, } from './main/directives/range-slider';
+export { RatingIndicatorDirective, RatingIndicatorDirectiveEventsMap, RatingIndicatorDirectiveElement, } from './main/directives/rating-indicator';
+export { ResponsivePopoverDirective, ResponsivePopoverDirectiveEventsMap, ResponsivePopoverDirectiveElement, } from './main/directives/responsive-popover';
+export { SegmentedButtonDirective, SegmentedButtonDirectiveEventsMap, SegmentedButtonDirectiveElement, } from './main/directives/segmented-button';
+export { SegmentedButtonItemDirective, SegmentedButtonItemDirectiveEventsMap, SegmentedButtonItemDirectiveElement, } from './main/directives/segmented-button-item';
+export { SelectDirective, SelectDirectiveEventsMap, SelectDirectiveElement, } from './main/directives/select';
+export { SliderDirective, SliderDirectiveCva, SliderDirectiveEventsMap, SliderDirectiveElement, } from './main/directives/slider';
+export { SliderBaseDirective, SliderBaseDirectiveEventsMap, SliderBaseDirectiveElement, } from './main/directives/slider-base';
+export { SplitButtonDirective, SplitButtonDirectiveEventsMap, SplitButtonDirectiveElement, } from './main/directives/split-button';
+export { StandardListItemDirective, StandardListItemDirectiveEventsMap, StandardListItemDirectiveElement, } from './main/directives/standard-list-item';
+export { StepInputDirective, StepInputDirectiveEventsMap, StepInputDirectiveElement, } from './main/directives/step-input';
+export { SuggestionGroupItemDirective, SuggestionGroupItemDirectiveElement, } from './main/directives/suggestion-group-item';
+export { SuggestionItemDirective, SuggestionItemDirectiveElement, } from './main/directives/suggestion-item';
+export { SwitchDirective, SwitchDirectiveCva, SwitchDirectiveEventsMap, SwitchDirectiveElement, } from './main/directives/switch';
+export { TabDirective, TabDirectiveElement } from './main/directives/tab';
+export { TabContainerDirective, TabContainerDirectiveEventsMap, TabContainerDirectiveElement, } from './main/directives/tab-container';
+export { TableDirective, TableDirectiveEventsMap, TableDirectiveElement, } from './main/directives/table';
+export { TableCellDirective, TableCellDirectiveElement, } from './main/directives/table-cell';
+export { TableColumnDirective, TableColumnDirectiveElement, } from './main/directives/table-column';
+export { TableGroupRowDirective, TableGroupRowDirectiveElement, } from './main/directives/table-group-row';
+export { TableRowDirective, TableRowDirectiveElement, } from './main/directives/table-row';
+export { TabSeparatorDirective, TabSeparatorDirectiveElement, } from './main/directives/tab-separator';
+export { TextAreaDirective, TextAreaDirectiveEventsMap, TextAreaDirectiveElement, } from './main/directives/text-area';
+export { TimePickerDirective, TimePickerDirectiveCva, TimePickerDirectiveEventsMap, TimePickerDirectiveElement, } from './main/directives/time-picker';
+export { TitleDirective, TitleDirectiveElement } from './main/directives/title';
+export { ToastDirective, ToastDirectiveElement } from './main/directives/toast';
+export { ToggleButtonDirective, ToggleButtonDirectiveEventsMap, ToggleButtonDirectiveElement, } from './main/directives/toggle-button';
+export { TokenDirective, TokenDirectiveEventsMap, TokenDirectiveElement, } from './main/directives/token';
+export { TreeDirective, TreeDirectiveEventsMap, TreeDirectiveElement, } from './main/directives/tree';
+export { TreeItemDirective, TreeItemDirectiveEventsMap, TreeItemDirectiveElement, } from './main/directives/tree-item';
+export { TreeItemCustomDirective, TreeItemCustomDirectiveEventsMap, TreeItemCustomDirectiveElement, } from './main/directives/tree-item-custom';
+export { WheelSliderDirective, WheelSliderDirectiveElement, } from './main/directives/wheel-slider';
+export { YearPickerDirective, YearPickerDirectiveEventsMap, YearPickerDirectiveElement, } from './main/directives/year-picker';
+export { Ui5FioriModule } from './fiori/ui5-fiori.module';
+export { Ui5MainModule } from './main/ui5-main.module';
+export { Ui5AngularModule } from './ui5-angular.module';
+export { Ui5WebcomponentsThemingModule } from './main/ui5-webcomponents-theming.module';
+export { Ui5WebcomponentsThemingService } from './main/ui5-webcomponents-theming.service';

package/main/directives/avatar-group.d.ts

@@ -0,0 +1,38 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/AvatarGroup.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface AvatarGroupDirectiveEventsMap extends Omit<HTMLElementEventMap, 'click' | 'overflow'> {
+    click: CustomEvent<{
+        targetRef: HTMLElement;
+        overflowButtonClicked: boolean;
+    }>;
+    overflow: CustomEvent<void>;
+}
+interface AvatarGroupDirectiveElement extends Omit<HTMLElement, 'colorScheme' | 'hiddenItems' | 'type' | 'click' | 'overflow' | 'overflowButton'> {
+    colorScheme: Array<'Accent1' | 'Accent10' | 'Accent2' | 'Accent3' | 'Accent4' | 'Accent5' | 'Accent6' | 'Accent7' | 'Accent8' | 'Accent9' | 'Placeholder'>;
+    hiddenItems: Array<HTMLElement>;
+    type: 'Group' | 'Individual';
+    overflowButton: HTMLElement;
+    addEventListener<K extends keyof AvatarGroupDirectiveEventsMap>(type: K, listener: (this: AvatarGroupDirectiveElement, ev: AvatarGroupDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof AvatarGroupDirectiveEventsMap>(type: K, listener: (this: AvatarGroupDirectiveElement, ev: AvatarGroupDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class AvatarGroupDirective {
+    private elementRef;
+    set colorScheme(val: AvatarGroupDirectiveElement['colorScheme']);
+    get colorScheme(): AvatarGroupDirectiveElement['colorScheme'];
+    set hiddenItems(val: AvatarGroupDirectiveElement['hiddenItems']);
+    get hiddenItems(): AvatarGroupDirectiveElement['hiddenItems'];
+    set type(val: AvatarGroupDirectiveElement['type']);
+    get type(): AvatarGroupDirectiveElement['type'];
+    click: Observable<AvatarGroupDirectiveEventsMap['click']>;
+    overflow: Observable<AvatarGroupDirectiveEventsMap['overflow']>;
+    constructor(elementRef: ElementRef<AvatarGroupDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get overflowButton(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AvatarGroupDirective, "ui5-avatar-group", ["ui5AvatarGroup"], { "colorScheme": "colorScheme"; "hiddenItems": "hiddenItems"; "type": "type"; }, { "click": "click"; "overflow": "overflow"; }, never, never, false, never>;
+}
+export { AvatarGroupDirective, AvatarGroupDirectiveEventsMap, AvatarGroupDirectiveElement, };

package/main/directives/avatar.d.ts

@@ -0,0 +1,36 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Avatar.js';
+import * as i0 from "@angular/core";
+interface AvatarDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'colorScheme' | 'icon' | 'initials' | 'interactive' | 'shape' | 'size' | 'badge'> {
+    accessibleName: string;
+    colorScheme: 'Accent1' | 'Accent10' | 'Accent2' | 'Accent3' | 'Accent4' | 'Accent5' | 'Accent6' | 'Accent7' | 'Accent8' | 'Accent9' | 'Placeholder';
+    icon: string;
+    initials: string;
+    interactive: boolean;
+    shape: 'Circle' | 'Square';
+    size: 'L' | 'M' | 'S' | 'XL' | 'XS';
+    badge: HTMLElement;
+}
+declare class AvatarDirective {
+    private elementRef;
+    set accessibleName(val: AvatarDirectiveElement['accessibleName']);
+    get accessibleName(): AvatarDirectiveElement['accessibleName'];
+    set colorScheme(val: AvatarDirectiveElement['colorScheme']);
+    get colorScheme(): AvatarDirectiveElement['colorScheme'];
+    set icon(val: AvatarDirectiveElement['icon']);
+    get icon(): AvatarDirectiveElement['icon'];
+    set initials(val: AvatarDirectiveElement['initials']);
+    get initials(): AvatarDirectiveElement['initials'];
+    set interactive(val: AvatarDirectiveElement['interactive']);
+    get interactive(): AvatarDirectiveElement['interactive'];
+    set shape(val: AvatarDirectiveElement['shape']);
+    get shape(): AvatarDirectiveElement['shape'];
+    set size(val: AvatarDirectiveElement['size']);
+    get size(): AvatarDirectiveElement['size'];
+    constructor(elementRef: ElementRef<AvatarDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get badge(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AvatarDirective, "ui5-avatar", ["ui5Avatar"], { "accessibleName": "accessibleName"; "colorScheme": "colorScheme"; "icon": "icon"; "initials": "initials"; "interactive": "interactive"; "shape": "shape"; "size": "size"; }, {}, never, never, false, never>;
+}
+export { AvatarDirective, AvatarDirectiveElement };

package/main/directives/badge.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Badge.js';
+import { IconDirective } from './icon';
+import * as i0 from "@angular/core";
+interface BadgeDirectiveElement extends Omit<HTMLElement, 'colorScheme' | 'icon'> {
+    colorScheme: string;
+    icon: IconDirective['element'];
+}
+declare class BadgeDirective {
+    private elementRef;
+    set colorScheme(val: BadgeDirectiveElement['colorScheme']);
+    get colorScheme(): BadgeDirectiveElement['colorScheme'];
+    constructor(elementRef: ElementRef<BadgeDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get icon(): IconDirective['element'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BadgeDirective, "ui5-badge", ["ui5Badge"], { "colorScheme": "colorScheme"; }, {}, never, never, false, never>;
+}
+export { BadgeDirective, BadgeDirectiveElement };

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

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/BreadcrumbsItem.js';
+import * as i0 from "@angular/core";
+interface BreadcrumbsItemDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'href' | 'target'> {
+    accessibleName: string;
+    href: string;
+    target: string;
+}
+declare class BreadcrumbsItemDirective {
+    private elementRef;
+    set accessibleName(val: BreadcrumbsItemDirectiveElement['accessibleName']);
+    get accessibleName(): BreadcrumbsItemDirectiveElement['accessibleName'];
+    set href(val: BreadcrumbsItemDirectiveElement['href']);
+    get href(): BreadcrumbsItemDirectiveElement['href'];
+    set target(val: BreadcrumbsItemDirectiveElement['target']);
+    get target(): BreadcrumbsItemDirectiveElement['target'];
+    constructor(elementRef: ElementRef<BreadcrumbsItemDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbsItemDirective, "ui5-breadcrumbs-item", ["ui5BreadcrumbsItem"], { "accessibleName": "accessibleName"; "href": "href"; "target": "target"; }, {}, never, never, false, never>;
+}
+export { BreadcrumbsItemDirective, BreadcrumbsItemDirectiveElement };

package/main/directives/breadcrumbs.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Breadcrumbs.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface BreadcrumbsDirectiveEventsMap extends Omit<HTMLElementEventMap, 'itemClick'> {
+    itemClick: CustomEvent<{
+        item: HTMLElement;
+        altKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        shiftKey: boolean;
+    }>;
+}
+interface BreadcrumbsDirectiveElement extends Omit<HTMLElement, 'design' | 'separatorStyle' | 'itemClick'> {
+    design: 'NoCurrentPage' | 'Standard';
+    separatorStyle: 'BackSlash' | 'DoubleBackSlash' | 'DoubleGreaterThan' | 'DoubleSlash' | 'GreaterThan' | 'Slash';
+    addEventListener<K extends keyof BreadcrumbsDirectiveEventsMap>(type: K, listener: (this: BreadcrumbsDirectiveElement, ev: BreadcrumbsDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof BreadcrumbsDirectiveEventsMap>(type: K, listener: (this: BreadcrumbsDirectiveElement, ev: BreadcrumbsDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class BreadcrumbsDirective {
+    private elementRef;
+    set design(val: BreadcrumbsDirectiveElement['design']);
+    get design(): BreadcrumbsDirectiveElement['design'];
+    set separatorStyle(val: BreadcrumbsDirectiveElement['separatorStyle']);
+    get separatorStyle(): BreadcrumbsDirectiveElement['separatorStyle'];
+    itemClick: Observable<BreadcrumbsDirectiveEventsMap['itemClick']>;
+    constructor(elementRef: ElementRef<BreadcrumbsDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbsDirective, "ui5-breadcrumbs", ["ui5Breadcrumbs"], { "design": "design"; "separatorStyle": "separatorStyle"; }, { "itemClick": "itemClick"; }, never, never, false, never>;
+}
+export { BreadcrumbsDirective, BreadcrumbsDirectiveEventsMap, BreadcrumbsDirectiveElement, };

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

@@ -0,0 +1,25 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/BusyIndicator.js';
+import * as i0 from "@angular/core";
+interface BusyIndicatorDirectiveElement extends Omit<HTMLElement, 'active' | 'delay' | 'size' | 'text'> {
+    active: boolean;
+    delay: any;
+    size: 'Large' | 'Medium' | 'Small';
+    text: string;
+}
+declare class BusyIndicatorDirective {
+    private elementRef;
+    set active(val: BusyIndicatorDirectiveElement['active']);
+    get active(): BusyIndicatorDirectiveElement['active'];
+    set delay(val: BusyIndicatorDirectiveElement['delay']);
+    get delay(): BusyIndicatorDirectiveElement['delay'];
+    set size(val: BusyIndicatorDirectiveElement['size']);
+    get size(): BusyIndicatorDirectiveElement['size'];
+    set text(val: BusyIndicatorDirectiveElement['text']);
+    get text(): BusyIndicatorDirectiveElement['text'];
+    constructor(elementRef: ElementRef<BusyIndicatorDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BusyIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BusyIndicatorDirective, "ui5-busy-indicator", ["ui5BusyIndicator"], { "active": "active"; "delay": "delay"; "size": "size"; "text": "text"; }, {}, never, never, false, never>;
+}
+export { BusyIndicatorDirective, BusyIndicatorDirectiveElement };

package/main/directives/button.d.ts

@@ -0,0 +1,53 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Button.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ButtonDirectiveEventsMap extends Omit<HTMLElementEventMap, 'click'> {
+    click: CustomEvent<void>;
+}
+interface ButtonDirectiveElement extends Omit<HTMLElement, 'accessibilityAttributes' | 'accessibleName' | 'accessibleNameRef' | 'design' | 'disabled' | 'icon' | 'iconEnd' | 'submits' | 'tooltip' | 'click'> {
+    accessibilityAttributes: {
+        expanded?: boolean;
+        hasPopup?: 'Dialog' | 'Grid' | 'Listbox' | 'Menu' | 'Tree';
+        controls?: string | HTMLElement | Array<HTMLElement | string>;
+    };
+    accessibleName: string;
+    accessibleNameRef: string;
+    design: 'Attention' | 'Default' | 'Emphasized' | 'Negative' | 'Positive' | 'Transparent';
+    disabled: boolean;
+    icon: string;
+    iconEnd: boolean;
+    submits: boolean;
+    tooltip: string;
+    addEventListener<K extends keyof ButtonDirectiveEventsMap>(type: K, listener: (this: ButtonDirectiveElement, ev: ButtonDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof ButtonDirectiveEventsMap>(type: K, listener: (this: ButtonDirectiveElement, ev: ButtonDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class ButtonDirective {
+    private elementRef;
+    set accessibilityAttributes(val: ButtonDirectiveElement['accessibilityAttributes']);
+    get accessibilityAttributes(): ButtonDirectiveElement['accessibilityAttributes'];
+    set accessibleName(val: ButtonDirectiveElement['accessibleName']);
+    get accessibleName(): ButtonDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: ButtonDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): ButtonDirectiveElement['accessibleNameRef'];
+    set design(val: ButtonDirectiveElement['design']);
+    get design(): ButtonDirectiveElement['design'];
+    set disabled(val: ButtonDirectiveElement['disabled']);
+    get disabled(): ButtonDirectiveElement['disabled'];
+    set icon(val: ButtonDirectiveElement['icon']);
+    get icon(): ButtonDirectiveElement['icon'];
+    set iconEnd(val: ButtonDirectiveElement['iconEnd']);
+    get iconEnd(): ButtonDirectiveElement['iconEnd'];
+    set submits(val: ButtonDirectiveElement['submits']);
+    get submits(): ButtonDirectiveElement['submits'];
+    set tooltip(val: ButtonDirectiveElement['tooltip']);
+    get tooltip(): ButtonDirectiveElement['tooltip'];
+    click: Observable<ButtonDirectiveEventsMap['click']>;
+    constructor(elementRef: ElementRef<ButtonDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonDirective, "ui5-button", ["ui5Button"], { "accessibilityAttributes": "accessibilityAttributes"; "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "design": "design"; "disabled": "disabled"; "icon": "icon"; "iconEnd": "iconEnd"; "submits": "submits"; "tooltip": "tooltip"; }, { "click": "click"; }, never, never, false, never>;
+}
+export { ButtonDirective, ButtonDirectiveEventsMap, ButtonDirectiveElement };

package/main/directives/calendar-date.d.ts

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

package/main/directives/calendar.d.ts

@@ -0,0 +1,50 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Calendar.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface CalendarDirectiveEventsMap extends Omit<HTMLElementEventMap, 'selectedDatesChange'> {
+    selectedDatesChange: CustomEvent<{
+        values: Array<any>;
+        dates: Array<any>;
+    }>;
+}
+interface CalendarDirectiveElement extends Omit<HTMLElement, 'formatPattern' | 'maxDate' | 'minDate' | 'primaryCalendarType' | 'secondaryCalendarType' | 'hideWeekNumbers' | 'selectionMode' | 'selectedDatesChange'> {
+    formatPattern: string;
+    maxDate: string;
+    minDate: string;
+    primaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    secondaryCalendarType: 'Buddhist' | 'Gregorian' | 'Islamic' | 'Japanese' | 'Persian';
+    hideWeekNumbers: boolean;
+    selectionMode: 'Multiple' | 'Range' | 'Single';
+    addEventListener<K extends keyof CalendarDirectiveEventsMap>(type: K, listener: (this: CalendarDirectiveElement, ev: CalendarDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof CalendarDirectiveEventsMap>(type: K, listener: (this: CalendarDirectiveElement, ev: CalendarDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    _safelyModifyTimestampBy(amount: any, unit: any): any;
+    _safelySetTimestamp(timestamp: any): any;
+}
+declare class CalendarDirective {
+    private elementRef;
+    set formatPattern(val: CalendarDirectiveElement['formatPattern']);
+    get formatPattern(): CalendarDirectiveElement['formatPattern'];
+    set maxDate(val: CalendarDirectiveElement['maxDate']);
+    get maxDate(): CalendarDirectiveElement['maxDate'];
+    set minDate(val: CalendarDirectiveElement['minDate']);
+    get minDate(): CalendarDirectiveElement['minDate'];
+    set primaryCalendarType(val: CalendarDirectiveElement['primaryCalendarType']);
+    get primaryCalendarType(): CalendarDirectiveElement['primaryCalendarType'];
+    set secondaryCalendarType(val: CalendarDirectiveElement['secondaryCalendarType']);
+    get secondaryCalendarType(): CalendarDirectiveElement['secondaryCalendarType'];
+    set hideWeekNumbers(val: CalendarDirectiveElement['hideWeekNumbers']);
+    get hideWeekNumbers(): CalendarDirectiveElement['hideWeekNumbers'];
+    set selectionMode(val: CalendarDirectiveElement['selectionMode']);
+    get selectionMode(): CalendarDirectiveElement['selectionMode'];
+    selectedDatesChange: Observable<CalendarDirectiveEventsMap['selectedDatesChange']>;
+    constructor(elementRef: ElementRef<CalendarDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    _safelyModifyTimestampBy(amount: any, unit: any): any;
+    _safelySetTimestamp(timestamp: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalendarDirective, "ui5-calendar", ["ui5Calendar"], { "formatPattern": "formatPattern"; "maxDate": "maxDate"; "minDate": "minDate"; "primaryCalendarType": "primaryCalendarType"; "secondaryCalendarType": "secondaryCalendarType"; "hideWeekNumbers": "hideWeekNumbers"; "selectionMode": "selectionMode"; }, { "selectedDatesChange": "selectedDatesChange"; }, never, never, false, never>;
+}
+export { CalendarDirective, CalendarDirectiveEventsMap, CalendarDirectiveElement, };

package/main/directives/card-header.d.ts

@@ -0,0 +1,38 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/CardHeader.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface CardHeaderDirectiveEventsMap extends Omit<HTMLElementEventMap, 'click'> {
+    click: CustomEvent<void>;
+}
+interface CardHeaderDirectiveElement extends Omit<HTMLElement, 'interactive' | 'status' | 'subtitleText' | 'titleText' | 'click' | 'action' | 'avatar'> {
+    interactive: boolean;
+    status: string;
+    subtitleText: string;
+    titleText: string;
+    action: Array<HTMLElement>;
+    avatar: Array<HTMLElement>;
+    addEventListener<K extends keyof CardHeaderDirectiveEventsMap>(type: K, listener: (this: CardHeaderDirectiveElement, ev: CardHeaderDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof CardHeaderDirectiveEventsMap>(type: K, listener: (this: CardHeaderDirectiveElement, ev: CardHeaderDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class CardHeaderDirective {
+    private elementRef;
+    set interactive(val: CardHeaderDirectiveElement['interactive']);
+    get interactive(): CardHeaderDirectiveElement['interactive'];
+    set status(val: CardHeaderDirectiveElement['status']);
+    get status(): CardHeaderDirectiveElement['status'];
+    set subtitleText(val: CardHeaderDirectiveElement['subtitleText']);
+    get subtitleText(): CardHeaderDirectiveElement['subtitleText'];
+    set titleText(val: CardHeaderDirectiveElement['titleText']);
+    get titleText(): CardHeaderDirectiveElement['titleText'];
+    click: Observable<CardHeaderDirectiveEventsMap['click']>;
+    constructor(elementRef: ElementRef<CardHeaderDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get action(): Array<HTMLElement>;
+    get avatar(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CardHeaderDirective, "ui5-card-header", ["ui5CardHeader"], { "interactive": "interactive"; "status": "status"; "subtitleText": "subtitleText"; "titleText": "titleText"; }, { "click": "click"; }, never, never, false, never>;
+}
+export { CardHeaderDirective, CardHeaderDirectiveEventsMap, CardHeaderDirectiveElement, };

package/main/directives/card.d.ts

@@ -0,0 +1,21 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Card.js';
+import * as i0 from "@angular/core";
+interface CardDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'header'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    header: Array<HTMLElement>;
+}
+declare class CardDirective {
+    private elementRef;
+    set accessibleName(val: CardDirectiveElement['accessibleName']);
+    get accessibleName(): CardDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: CardDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): CardDirectiveElement['accessibleNameRef'];
+    constructor(elementRef: ElementRef<CardDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    get header(): Array<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CardDirective, "ui5-card", ["ui5Card"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; }, {}, never, never, false, never>;
+}
+export { CardDirective, CardDirectiveElement };

package/main/directives/carousel.d.ts

@@ -0,0 +1,47 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/Carousel.js';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface CarouselDirectiveEventsMap extends Omit<HTMLElementEventMap, 'navigate'> {
+    navigate: CustomEvent<{
+        selectedIndex: number;
+    }>;
+}
+interface CarouselDirectiveElement extends Omit<HTMLElement, 'arrowsPlacement' | 'cyclic' | 'hideNavigationArrows' | 'hidePageIndicator' | 'itemsPerPageL' | 'itemsPerPageM' | 'itemsPerPageS' | 'navigate'> {
+    arrowsPlacement: 'Content' | 'Navigation';
+    cyclic: boolean;
+    hideNavigationArrows: boolean;
+    hidePageIndicator: boolean;
+    itemsPerPageL: any;
+    itemsPerPageM: any;
+    itemsPerPageS: any;
+    addEventListener<K extends keyof CarouselDirectiveEventsMap>(type: K, listener: (this: CarouselDirectiveElement, ev: CarouselDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof CarouselDirectiveEventsMap>(type: K, listener: (this: CarouselDirectiveElement, ev: CarouselDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    navigateTo(itemIndex: number): any;
+}
+declare class CarouselDirective {
+    private elementRef;
+    set arrowsPlacement(val: CarouselDirectiveElement['arrowsPlacement']);
+    get arrowsPlacement(): CarouselDirectiveElement['arrowsPlacement'];
+    set cyclic(val: CarouselDirectiveElement['cyclic']);
+    get cyclic(): CarouselDirectiveElement['cyclic'];
+    set hideNavigationArrows(val: CarouselDirectiveElement['hideNavigationArrows']);
+    get hideNavigationArrows(): CarouselDirectiveElement['hideNavigationArrows'];
+    set hidePageIndicator(val: CarouselDirectiveElement['hidePageIndicator']);
+    get hidePageIndicator(): CarouselDirectiveElement['hidePageIndicator'];
+    set itemsPerPageL(val: CarouselDirectiveElement['itemsPerPageL']);
+    get itemsPerPageL(): CarouselDirectiveElement['itemsPerPageL'];
+    set itemsPerPageM(val: CarouselDirectiveElement['itemsPerPageM']);
+    get itemsPerPageM(): CarouselDirectiveElement['itemsPerPageM'];
+    set itemsPerPageS(val: CarouselDirectiveElement['itemsPerPageS']);
+    get itemsPerPageS(): CarouselDirectiveElement['itemsPerPageS'];
+    navigate: Observable<CarouselDirectiveEventsMap['navigate']>;
+    constructor(elementRef: ElementRef<CarouselDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    navigateTo(itemIndex: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CarouselDirective, "ui5-carousel", ["ui5Carousel"], { "arrowsPlacement": "arrowsPlacement"; "cyclic": "cyclic"; "hideNavigationArrows": "hideNavigationArrows"; "hidePageIndicator": "hidePageIndicator"; "itemsPerPageL": "itemsPerPageL"; "itemsPerPageM": "itemsPerPageM"; "itemsPerPageS": "itemsPerPageS"; }, { "navigate": "navigate"; }, never, never, false, never>;
+}
+export { CarouselDirective, CarouselDirectiveEventsMap, CarouselDirectiveElement, };

package/main/directives/check-box.d.ts

@@ -0,0 +1,62 @@
+import { ElementRef } from '@angular/core';
+import '@ui5/webcomponents/dist/CheckBox.js';
+import { Observable } from 'rxjs';
+import { GenericControlValueAccessor } from '../../generic-cva';
+import * as i0 from "@angular/core";
+interface CheckBoxDirectiveEventsMap extends Omit<HTMLElementEventMap, 'change'> {
+    change: CustomEvent<void>;
+}
+interface CheckBoxDirectiveElement extends Omit<HTMLElement, 'accessibleName' | 'accessibleNameRef' | 'checked' | 'disabled' | 'indeterminate' | 'name' | 'readonly' | 'required' | 'text' | 'valueState' | 'wrappingType' | 'change'> {
+    accessibleName: string;
+    accessibleNameRef: string;
+    checked: boolean;
+    disabled: boolean;
+    indeterminate: boolean;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    text: string;
+    valueState: 'Error' | 'Information' | 'None' | 'Success' | 'Warning';
+    wrappingType: 'None' | 'Normal';
+    addEventListener<K extends keyof CheckBoxDirectiveEventsMap>(type: K, listener: (this: CheckBoxDirectiveElement, ev: CheckBoxDirectiveEventsMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof CheckBoxDirectiveEventsMap>(type: K, listener: (this: CheckBoxDirectiveElement, ev: CheckBoxDirectiveEventsMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class CheckBoxDirective {
+    private elementRef;
+    set accessibleName(val: CheckBoxDirectiveElement['accessibleName']);
+    get accessibleName(): CheckBoxDirectiveElement['accessibleName'];
+    set accessibleNameRef(val: CheckBoxDirectiveElement['accessibleNameRef']);
+    get accessibleNameRef(): CheckBoxDirectiveElement['accessibleNameRef'];
+    set checked(val: CheckBoxDirectiveElement['checked']);
+    get checked(): CheckBoxDirectiveElement['checked'];
+    set disabled(val: CheckBoxDirectiveElement['disabled']);
+    get disabled(): CheckBoxDirectiveElement['disabled'];
+    set indeterminate(val: CheckBoxDirectiveElement['indeterminate']);
+    get indeterminate(): CheckBoxDirectiveElement['indeterminate'];
+    set name(val: CheckBoxDirectiveElement['name']);
+    get name(): CheckBoxDirectiveElement['name'];
+    set readonly(val: CheckBoxDirectiveElement['readonly']);
+    get readonly(): CheckBoxDirectiveElement['readonly'];
+    set required(val: CheckBoxDirectiveElement['required']);
+    get required(): CheckBoxDirectiveElement['required'];
+    set text(val: CheckBoxDirectiveElement['text']);
+    get text(): CheckBoxDirectiveElement['text'];
+    set valueState(val: CheckBoxDirectiveElement['valueState']);
+    get valueState(): CheckBoxDirectiveElement['valueState'];
+    set wrappingType(val: CheckBoxDirectiveElement['wrappingType']);
+    get wrappingType(): CheckBoxDirectiveElement['wrappingType'];
+    change: Observable<CheckBoxDirectiveEventsMap['change']>;
+    constructor(elementRef: ElementRef<CheckBoxDirectiveElement>);
+    get element(): typeof this.elementRef.nativeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckBoxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckBoxDirective, "ui5-checkbox", ["ui5Checkbox"], { "accessibleName": "accessibleName"; "accessibleNameRef": "accessibleNameRef"; "checked": "checked"; "disabled": "disabled"; "indeterminate": "indeterminate"; "name": "name"; "readonly": "readonly"; "required": "required"; "text": "text"; "valueState": "valueState"; "wrappingType": "wrappingType"; }, { "change": "change"; }, never, never, false, never>;
+}
+declare class CheckBoxDirectiveCva extends GenericControlValueAccessor {
+    private elementRef;
+    constructor(elementRef: ElementRef<CheckBoxDirective['element']>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckBoxDirectiveCva, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckBoxDirectiveCva, "ui5-checkbox", never, {}, {}, never, never, false, never>;
+}
+export { CheckBoxDirective, CheckBoxDirectiveCva, CheckBoxDirectiveEventsMap, CheckBoxDirectiveElement, };