@odx/angular 12.26.1 → 13.0.1

package/components/select/index.d.ts

@@ -1,6 +1,263 @@
-export * from './lib/components';
-export * from './lib/directives';
-export * from './lib/pipes';
-export * from './lib/select.component';
-export * from './lib/select.module';
-export * from './lib/select.tokens';
+import * as _odx_angular_components_select from '@odx/angular/components/select';
+import * as i0 from '@angular/core';
+import { OnInit, ElementRef, PipeTransform, AfterViewInit, QueryList, TemplateRef, InjectionToken } from '@angular/core';
+import { OptionControl } from '@odx/angular/cdk/option-control';
+import { Highlightable } from '@angular/cdk/a11y';
+import { InputControlDirective } from '@odx/angular/cdk/custom-form-control';
+import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
+import { BaseSearchFilterPipe, AutocompleteControl } from '@odx/angular/cdk/autocomplete-control';
+import * as i5 from '@odx/angular';
+import { IdentityMatcher } from '@odx/angular';
+
+/**
+ * SelectOptionComponent is a customizable option element for use within a SelectComponent.
+ * It supports complex data structures, integration with checkbox components for multi-select,
+ * and can be disabled as needed.
+ * It extends OptionControl to provide additional behavior specific to select components.
+ *
+ * @template T - The type of the value selected in the option.
+ * @see {OptionControl}
+ */
+declare class SelectOptionComponent<T = unknown> extends OptionControl<T> implements OnInit {
+    private _isDisabled;
+    protected readonly selectControl: _odx_angular_components_select.SelectComponent<unknown>;
+    /**
+     * Indicates whether the option is currently selected.
+     *
+     * @type {boolean}
+     */
+    isSelected: boolean;
+    /**
+     * Indicates whether a not found message should be displayed, used typically for search results.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    notFoundMessage: boolean;
+    /**
+     * Setter for the disabled state of the select option.
+     *
+     * @param value - The new value for the disabled state.
+     */
+    set disabled(value: boolean);
+    /**
+     * Getter for the disabled state of the select option.
+     *
+     * @returns {boolean} The current disabled state of the option.
+     */
+    get disabled(): boolean;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Sets active styles for the option when it becomes the target of keyboard navigation or mouse hover.
+     */
+    setActiveStyles(): void;
+    /**
+     * Toggles the selection state of the option when it is part of a multi-select control.
+     */
+    switchCheckbox(): void;
+    protected selectOption(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectOptionComponent<any>, "odx-select-option, odx-option", never, { "notFoundMessage": { "alias": "notFoundMessage"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_notFoundMessage: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class SelectAllDirective implements Highlightable {
+    protected isActive: boolean;
+    protected readonly element: ElementRef<HTMLElement>;
+    disabled: boolean;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    getLabel?(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAllDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectAllDirective, "[odxSelectAll]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * SelectInputControlDirective extends InputControlDirective to provide additional behavior
+ * specific to select components with search functionality. This directive manages interactions
+ * within the search input field, such as resetting the field content upon specific key events.
+ *
+ * @see {InputControlDirective}
+ */
+declare class SelectInputControlDirective extends InputControlDirective {
+    /**
+     * @internal
+     */
+    protected isReadonly: i0.Signal<void>;
+    /**
+     * @internal
+     */
+    isVisible: i0.WritableSignal<boolean>;
+    /**
+     * Dynamic content to be displayed when no matching search results are found.
+     * This can be specified as HTML content or a string.
+     *
+     * @type {DynamicContent | null}
+     * @default null
+     */
+    notFoundContent: DynamicContent | null;
+    protected handleDelete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectInputControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectInputControlDirective, "input[odxSelectSearchField]", never, { "notFoundContent": { "alias": "odxSelectSearchField"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * SelectSearchFilterPipe extends BaseSearchFilterPipe to provide search filtering functionality
+ * specifically for select components. It filters options based on the input query, supporting
+ * complex filtering logic as defined in the BaseSearchFilterPipe.
+ *
+ * This pipe is not pure, meaning it updates and reevaluates when inputs change or when
+ * impure actions occur in the application.
+ *
+ * @see {BaseSearchFilterPipe}
+ */
+declare class SelectSearchFilterPipe extends BaseSearchFilterPipe implements PipeTransform {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectSearchFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SelectSearchFilterPipe, "odxSelectSearchFilter", true>;
+}
+
+/**
+ * SelectComponent provides an advanced dropdown list that supports autocomplete, multiple selection,
+ * and accessibility features. It extends AutocompleteControl for seamless integration with Angular forms.
+ *
+ * @template T - The type of the value selected in the select.
+ *
+ * @see {AutocompleteControl}
+ */
+declare class SelectComponent<T = unknown> extends AutocompleteControl<T | null> implements AfterViewInit {
+    protected selectedOption: SelectOptionComponent<T> | null;
+    protected selectedOptionText: string | null;
+    protected options?: QueryList<SelectOptionComponent<T>>;
+    protected selectAllDirective?: SelectAllDirective;
+    protected isIndeterminateSelection: i0.WritableSignal<boolean>;
+    protected allOptionSelected: i0.WritableSignal<boolean>;
+    /**
+     * Directive managing the search input field within the select.
+     *
+     * @type {SelectInputControlDirective | undefined}
+     */
+    searchField?: SelectInputControlDirective;
+    /**
+     * Returns the content of the selected option for display. This can be a template or plain text.
+     *
+     * @type {TemplateRef<{ $implicit: T | null }> | string | null}
+     */
+    get selectedOptionContent(): TemplateRef<{
+        $implicit: T | null;
+    }> | string | null;
+    /**
+     * Helper flag: show selected value when search field is hidden and there's selected content.
+     */
+    get showSelectedValue(): boolean;
+    /**
+     * Helper flag: show placeholder when search field is hidden and there's no selected content.
+     */
+    get showPlaceholder(): boolean;
+    /**
+     * Placeholder text for the select input when no option is selected.
+     *
+     * @type {string}
+     * @default ''
+     */
+    placeholder: string;
+    /**
+     * When set to true, the select will display a reset button.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    clearable: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When set to true, the select will display a select all button.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    hasSelectAll: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Text to display for the select all button.
+     *
+     * @type {string}
+     * @default 'Select all'
+     */
+    hasSelectAllText: i0.InputSignal<string>;
+    /**
+     * Sets whether multiple options can be selected.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    multiple: boolean;
+    /**
+     * Custom template for displaying the selected option.
+     *
+     * @type {TemplateRef<{ $implicit: T }> | null}
+     * @default null
+     */
+    selectedOptionTemplate?: TemplateRef<{
+        $implicit: T;
+    }> | null;
+    /**
+     * Function to determine if two options are identical, useful for detecting changes in selection.
+     *
+     * @type {IdentityMatcher<T | null>}
+     * @default ODX_DEFAULT_IDENTITY_MATCHER
+     *
+     * @example
+     * ```ts
+     * (item1, item2) => item1.id === item2.id
+     * ```
+     */
+    identityMatcher: IdentityMatcher<T | null>;
+    ngAfterViewInit(): void;
+    /**
+     * Registers a function to be called when the value of the select changes.
+     *
+     * @param {Function} fn The function to be called when the value changes.
+     * @returns {void}
+     */
+    registerOnChange(fn: (value: T | null) => void): void;
+    /**
+     * Selects a given option and updates the component's value accordingly.
+     *
+     * @param {SelectOptionComponent<T | T[]> | null} option The option to select.
+     * @returns {void}
+     */
+    selectOption(option?: SelectOptionComponent<T | T[]> | null): void;
+    /**
+     * Checks whether a given option is selected.
+     *
+     * @param {SelectOptionComponent<T | T[]>} option The option to check.
+     * @returns {boolean} Whether the option is selected.
+     */
+    isOptionSelected(option: SelectOptionComponent<T | T[]>): boolean;
+    protected initKeyManager(options: Highlightable[]): void;
+    protected handleQueryListOption(options: QueryList<SelectOptionComponent<T>>): void;
+    protected handleSearchFieldChanges(): void;
+    protected clickSelectAll(event: Event): void;
+    protected handleControllerEvent(event: KeyboardEvent): void;
+    protected activateSelectedOption(): void;
+    protected onDropdownOpen(): void;
+    protected onDropdownClose(): void;
+    protected onDropdownOpened(): void;
+    protected onDropdownClosed(): void;
+    protected resetValue(event: Event): void;
+    private updateSelectedOption;
+    private multipleSelectValueResolver;
+    private selectAllHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent<any>, "odx-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "hasSelectAll": { "alias": "hasSelectAll"; "required": false; "isSignal": true; }; "hasSelectAllText": { "alias": "hasSelectAllText"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; }; "selectedOptionTemplate": { "alias": "selectedOptionTemplate"; "required": false; }; "identityMatcher": { "alias": "identityMatcher"; "required": false; }; }, {}, ["searchField", "options"], ["[odxSelectSearchField]", "*"], true, never>;
+    static ngAcceptInputType_multiple: unknown;
+}
+
+declare class SelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectModule, never, [typeof SelectComponent, typeof SelectInputControlDirective, typeof SelectSearchFilterPipe, typeof SelectOptionComponent], [typeof i5.CoreModule, typeof SelectComponent, typeof SelectInputControlDirective, typeof SelectSearchFilterPipe, typeof SelectOptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectModule>;
+}
+
+declare const SELECT_CONTROL: InjectionToken<SelectComponent<unknown>>;
+
+export { SELECT_CONTROL, SelectAllDirective, SelectComponent, SelectInputControlDirective, SelectModule, SelectOptionComponent, SelectSearchFilterPipe };

package/components/slider/index.d.ts

@@ -1 +1,37 @@
-export * from './lib/slider.directive';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@odx/angular';
+
+/**
+ * SliderDirective enhances an HTML input of type range by integrating custom slider functionality.
+ * It incorporates disabled state handling and custom style binding for visual feedback based on the slider's value.
+ * Has host directives for disabled state handling.
+ *
+ * @see {WithDisabledState}
+ */
+declare class SliderDirective {
+    readonly element: ElementRef<HTMLInputElement>;
+    /**
+     * Retrieves the current value of the slider.
+     *
+     * @returns {number}
+     */
+    get value(): number;
+    /**
+     * Retrieves the maximum value of the slider. Defaults to 100 if not specified.
+     *
+     * @returns {number}
+     */
+    get max(): number;
+    /**
+     * Retrieves the minimum value of the slider. Defaults to the native minimum if not specified.
+     *
+     * @returns {number}
+     */
+    get min(): number;
+    protected get valuePercentage(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderDirective, "input[type=range][odxSlider]", never, {}, {}, never, never, true, [{ directive: typeof i1.WithDisabledState; inputs: {}; outputs: {}; }]>;
+}
+
+export { SliderDirective };

package/components/spinbox/index.d.ts

@@ -1 +1,54 @@
-export * from './lib/spinbox.component';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
+import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
+
+/**
+ * SpinboxComponent is a custom form control for numeric input which allows users to increment and decrement
+ * the value using corresponding buttons. It supports keyboard navigation and automatic boundary checks for the values.
+ *  Extends CustomFormControl to provide additional behavior.
+ *
+ * @see {CustomFormControl}
+ */
+declare class SpinboxComponent extends CustomFormControl<number> implements AfterViewInit, OnDestroy {
+    private destroyIncrementListener;
+    private destroyDecrementListener;
+    private get inputElement();
+    protected decrementButton: ElementRef<HTMLButtonElement>;
+    protected incrementButton: ElementRef<HTMLButtonElement>;
+    readonly element: ElementRef<HTMLElement>;
+    /**
+     * The maximum allowable value for the spinbox.
+     *
+     * @type {number}
+     * @default Number.POSITIVE_INFINITY
+     */
+    max: number;
+    /**
+     * The minimum allowable value for the spinbox.
+     *
+     * @type {number}
+     * @default Number.NEGATIVE_INFINITY
+     */
+    min: number;
+    /**
+     * The value increment or decrement step for the spinbox.
+     *
+     * @type {number}
+     * @default 1
+     */
+    step: number;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    updateValue(value: number): void;
+    protected maxSteps({ code }: KeyboardEvent): void;
+    protected checkAndUpdate(): void;
+    private pressAndHold;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinboxComponent, "odx-spinbox", never, { "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "step": { "alias": "step"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_max: unknown;
+    static ngAcceptInputType_min: unknown;
+    static ngAcceptInputType_step: unknown;
+}
+
+export { SpinboxComponent };

package/components/switch/index.d.ts

@@ -1,3 +1,44 @@
-export * from './lib/switch.component';
-export * from './lib/switch.module';
-export * from './lib/switch.validator';
+import { CheckBoxControl } from '@odx/angular/cdk/checkbox-control';
+import * as i0 from '@angular/core';
+import * as i1 from '@odx/angular';
+import { CheckboxRequiredValidator } from '@angular/forms';
+
+/**
+ * SwitchComponent provides a custom switch (toggle) control that can be used within forms
+ * or standalone for toggling a specific binary state. It supports readonly and disabled states,
+ * and integrates seamlessly with Angular's form controls for data binding and state management.
+ * Has host directives for disabled state handling.
+ * Extends CheckBoxControl to provide additional behavior.
+ *
+ * @see {WithDisabledState}
+ * @see {CheckBoxControl}
+ */
+declare class SwitchComponent extends CheckBoxControl {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchComponent, "odx-switch", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.WithDisabledState; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * SwitchValidator extends CheckboxRequiredValidator to provide required field validation
+ * for switch components used within Angular forms. It ensures that the switch is marked as required
+ * and must be toggled (checked) to meet form validation criteria.
+ *
+ * This directive automatically attaches itself to any switch component with a 'required' attribute
+ * and a form control binding (formControlName, formControl, or ngModel).
+ *
+ * Extends CheckboxRequiredValidator.
+ *
+ * @see {CheckboxRequiredValidator}
+ */
+declare class SwitchValidator extends CheckboxRequiredValidator {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SwitchValidator, "odx-switch[required][formControlName], odx-switch[required][formControl], odx-switch[required][ngModel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SwitchModule, never, [typeof SwitchComponent, typeof SwitchValidator], [typeof i1.CoreModule, typeof SwitchComponent, typeof SwitchValidator]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SwitchModule>;
+}
+
+export { SwitchComponent, SwitchModule, SwitchValidator };

package/components/tab-bar/index.d.ts

@@ -1,4 +1,141 @@
-export * from './lib/components';
-export * from './lib/models';
-export * from './lib/tab-bar.component';
-export * from './lib/tab-bar.module';
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef } from '@angular/core';
+import { Highlightable, ActiveDescendantKeyManager } from '@angular/cdk/a11y';
+import * as i3 from '@odx/angular';
+
+/**
+ * Represents an individual tab item in a tab bar interface, providing functionalities
+ * for activation, deactivation, and optional closing of the tab. This component is designed
+ * to be used within a `TabBarComponent` to create a complete tabbed interface.
+ *
+ * It supports disabled state management through `DisabledController`, allowing the tab to be
+ * disabled based on parent component states or its own `disabled` input property.
+ *
+ * The component integrates with Angular's `RouterLinkActive` to automatically set active
+ * styles based on the current router state, enhancing SPA navigation experiences.
+ */
+declare class TabBarItemComponent implements Highlightable, OnInit {
+    private readonly disabledController;
+    private readonly tabBar;
+    private readonly routerLinkActive;
+    private readonly takeUntilDestroyed;
+    protected isActive: boolean;
+    readonly element: ElementRef<HTMLElement>;
+    get disabled(): boolean;
+    /**
+     * Indicates if the tab can be closed. This controls the visibility of the close button
+     * and enables the emission of the `tabClose` event when the tab is closed.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Event emitter that fires when the tab is closed. It emits the instance of the tab item component.
+     *
+     * @emits {TabBarItemComponent}
+     */
+    tabClose: _angular_core.OutputEmitterRef<TabBarItemComponent>;
+    ngOnInit(): void;
+    /**
+     * Sets the tab as active and applies corresponding styles. This method is part of the
+     * `Highlightable` interface, allowing the tab bar to manage active states.
+     */
+    setActiveStyles(): void;
+    /**
+     * Sets the tab as inactive and removes corresponding active styles. This method is part of the
+     * `Highlightable` interface.
+     */
+    setInactiveStyles(): void;
+    protected onClick(): void;
+    protected handleClose(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabBarItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabBarItemComponent, "odx-tab-bar-item", never, { "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "tabClose": "tabClose"; }, never, ["odx-icon", "*"], true, never>;
+}
+
+interface TabChangeEvent {
+    selectedIndex: number;
+    selectedTab: TabBarItemComponent | null;
+}
+
+/**
+ * `TabBarComponent` creates a dynamic and accessible tab bar interface,
+ * facilitating the management and interaction with a collection of tabs.
+ * It supports keyboard navigation, dynamic tab management, and responsive overflow actions.
+ *
+ * The component integrates with Angular's ContentChildren to dynamically manage the tabs based on their content.
+ * It uses ActiveDescendantKeyManager from Angular CDK for managing focus and keyboard navigation,
+ * making it accessible and user-friendly. Additionally, it handles overflow with navigational arrows,
+ * allowing for a smooth user experience even with a large number of tabs.
+ */
+declare class TabBarComponent {
+    private readonly takeUntilDestroyed;
+    private readonly scrollableService;
+    protected readonly nextTab: _angular_core.WritableSignal<HTMLElement | null>;
+    protected readonly prevTab: _angular_core.WritableSignal<HTMLElement | null>;
+    protected readonly tabs: _angular_core.Signal<readonly TabBarItemComponent[]>;
+    protected readonly activeItem: _angular_core.Signal<TabBarItemComponent | null>;
+    protected readonly keyManager: ActiveDescendantKeyManager<TabBarItemComponent>;
+    protected readonly scrollContainerElement: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly element: ElementRef<HTMLElement>;
+    /**
+     * Index of the currently selected tab. Use this property to programmatically
+     * change the active tab. It responds to changes by updating the active state of the corresponding
+     * tab item and adjusting the view if necessary.
+     *
+     * @type {number}
+     * @example
+     * Programmatically select the second tab (index starts from 0):
+     * ```html
+     * <odx-tab-bar [selectedIndex]="1"></odx-tab-bar>
+     * ```
+     */
+    selectedIndex: _angular_core.ModelSignal<number>;
+    /**
+     * An EventEmitter that emits whenever a new tab is selected. It provides the `TabChangeEvent`
+     * which contains the index of the newly selected tab and the instance of the corresponding
+     * `TabBarItemComponent`. Subscribe to this output to perform actions when the active tab changes.
+     *
+     * @emits {TabChangeEvent}
+     * @example
+     * ```html
+     * <odx-tab-bar (selectedTabChanged)="onTabChange($event)"></odx-tab-bar>
+     * ```
+     *
+     * ```ts
+     * onTabChange(event: TabChangeEvent): void {
+     *   console.log(`New active tab index: ${event.selectedIndex}`);
+     * }
+     * ```
+     */
+    selectedTabChanged: _angular_core.OutputEmitterRef<TabChangeEvent>;
+    constructor();
+    /**
+     * Activates the specified tab item, making it the currently selected tab.
+     * If the item is already active, no action is taken.
+     *
+     * @param {TabBarItemComponent | null} item - The tab item to activate.
+     */
+    activateItem(item?: TabBarItemComponent | null): void;
+    /**
+     * Fires when the specified tab item is removed from the tab bar.
+     * If the item is currently active, the previous tab is activated.
+     *
+     * @param {TabBarItemComponent} item - The tab item to remove.
+     */
+    removeItem(item: TabBarItemComponent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onFocused(): void;
+    protected scrollTabs(direction?: 1 | -1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabBarComponent, "odx-tab-bar", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectedTabChanged": "selectedTabChanged"; }, ["tabs"], ["*"], true, never>;
+}
+
+declare class TabBarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabBarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TabBarModule, never, [typeof TabBarComponent, typeof TabBarItemComponent], [typeof i3.CoreModule, typeof TabBarComponent, typeof TabBarItemComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TabBarModule>;
+}
+
+export { TabBarComponent, TabBarItemComponent, TabBarModule };
+export type { TabChangeEvent };