@odx/angular 6.0.0 → 6.1.0

package/components/radio-group/lib/components/radio-button/radio-button.component.d.ts

@@ -1,6 +1,23 @@
 import { AfterViewInit, ElementRef } from '@angular/core';
 import { RadioControlDirective } from '@odx/angular/cdk/radio-group-control';
 import * as i0 from "@angular/core";
+/**
+ * Represents a radio button component.
+ * @extends {RadioControlDirective<T>}
+ *
+ * @remarks
+ * To add subtitle text to the radio button, use class `odx-radio-button__subtitle` in template's content.
+ *
+ * @example
+ * ```html
+ * <odx-radio-group>
+ *  <odx-radio-button [value]="'a'" >
+ *   Radio button label
+ *   <span class="odx-radio-button__subtitle">Subtitle text</span>
+ *  </odx-radio-button>
+ * </odx-radio-group>
+ * ```
+ */
 export declare class RadioButtonComponent<T = unknown> extends RadioControlDirective<T> implements AfterViewInit {
     protected withLabel: boolean;
     readonly element: ElementRef<HTMLElement>;
@@ -8,5 +25,5 @@ export declare class RadioButtonComponent<T = unknown> extends RadioControlDirec
     ngAfterViewInit(): void;
     protected onContentChange(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent<any>, "odx-radio-button", never, {}, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent<any>, "odx-radio-button", never, {}, {}, never, ["*", ".odx-radio-button__subtitle"], true, never>;
 }

package/components/radio-group/lib/radio-group.component.d.ts

@@ -1,7 +1,18 @@
 import { RadioGroupControlDirective } from '@odx/angular/cdk/radio-group-control';
 import * as i0 from "@angular/core";
+/**
+ * RadioGroupComponent manages a group of radio buttons, providing Angular form control integration
+ * and additional states like disabled and readonly. It supports both vertical and horizontal layouts.
+ *
+ * The component extends the `RadioGroupControlDirective`, which provides the core functionality for managing.
+ * @see {RadioGroupControlDirective}
+ */
 export declare class RadioGroupComponent<T = unknown> extends RadioGroupControlDirective<T> {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Determines whether the radio buttons are arranged horizontally.
+     * When set to `true`, radio buttons are aligned side by side.
+     */
     horizontal: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent<any>, "odx-radio-group", never, { "horizontal": { "alias": "horizontal"; "required": false; }; }, {}, never, ["*"], true, never>;

package/components/rail-navigation/lib/components/rail-navigation-item/rail-navigation-item.component.d.ts

@@ -1,11 +1,30 @@
 import { RouterLinkActive } from '@angular/router';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * RailNavigationItemComponent represents an individual navigation item within a rail navigation system.
+ * This component can be used as either a link or a button and integrates with Angular's RouterLinkActive to
+ * optionally highlight active navigation items.
+ * Has host directives for disabled and tabindex states.
+ *
+ * @see {WithDisabledState}
+ * @see {WithTabIndex}
+ */
 export declare class RailNavigationItemComponent {
     protected readonly routerLinkActive: RouterLinkActive | null;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the navigation item is selected. This can be manually set or derived from router state.
+     * Uses booleanAttribute transformer for attribute binding.
+     */
     isSelected: boolean;
+    /**
+     * The name of the icon to be displayed. This input is required.
+     */
     iconName: string;
+    /**
+     * Optional input to specify the icon set from which the icon should be taken.
+     */
     iconSet: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<RailNavigationItemComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<RailNavigationItemComponent, "a[odxRailNavigationItem][iconName], button[odxRailNavigationItem][iconName]", never, { "isSelected": { "alias": "isSelected"; "required": false; }; "iconName": { "alias": "iconName"; "required": true; }; "iconSet": { "alias": "iconSet"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof i1.WithDisabledState; inputs: {}; outputs: {}; }, { directive: typeof i1.WithTabIndex; inputs: {}; outputs: {}; }]>;

package/components/rail-navigation/lib/rail-navigation.component.d.ts

@@ -1,13 +1,39 @@
 import { EventEmitter } from '@angular/core';
 import { RailNavigationVariant } from './models';
 import * as i0 from "@angular/core";
+/**
+ * RailNavigationComponent provides a navigational sidebar that can toggle between open and closed states.
+ * It supports different visual variants and can integrate individual navigation items
+ * for complex navigation structures.
+ */
 export declare class RailNavigationComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the rail navigation is open. Uses booleanAttribute transformer for attribute binding.
+     */
     isOpen: boolean;
+    /**
+     * Specifies the visual variant of the rail navigation.
+     * @see {RailNavigationVariant}
+     */
     variant: RailNavigationVariant;
+    /**
+     * Emits changes to the `isOpen` state, allowing for external reaction to state changes.
+     */
     isOpenChange: EventEmitter<boolean>;
+    /**
+     * Toggles the open state of the rail navigation. Optionally accepts a boolean to force the state to open or closed.
+     * Does not perform any action if the variant is set to BAR.
+     * @param forceState Optionally force the toggle to a specific state.
+     */
     toggle(forceState?: boolean): void;
+    /**
+     * Explicitly opens the rail navigation, setting `isOpen` to true.
+     */
     open(): void;
+    /**
+     * Explicitly closes the rail navigation, setting `isOpen` to false.
+     */
     close(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RailNavigationComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<RailNavigationComponent, "odx-rail-navigation", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, ["*"], true, never>;

package/components/rich-list/lib/components/rich-list-content/rich-list-content.component.d.ts

@@ -1,4 +1,8 @@
 import * as i0 from "@angular/core";
+/**
+ * RichListItemContentComponent provides a container for rich content within a `RichListItemComponent`.
+ * It is used to wrap content that should be styled according to the rich list design.
+ */
 export declare class RichListItemContentComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<RichListItemContentComponent, never>;

package/components/rich-list/lib/components/rich-list-header/rich-list-header.component.d.ts

@@ -1,4 +1,8 @@
 import * as i0 from "@angular/core";
+/**
+ * RichListItemHeaderComponent provides a container for header content within a `RichListItemComponent`.
+ * It is used to wrap content that should be styled according to the rich list design.
+ */
 export declare class RichListItemHeaderComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<RichListItemHeaderComponent, never>;

package/components/rich-list/lib/components/rich-list-item/rich-list-item.component.d.ts

@@ -2,13 +2,21 @@ import { EventEmitter } from '@angular/core';
 import { ExpandableItemDirective } from '@odx/angular/cdk/expandable';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/cdk/expandable";
+/**
+ * RichListItemComponent is a list item component that displays rich content and supports expandable functionality.
+ * It can be used in conjunction with the `RichListComponent` to create a list of items with rich content.
+ * The component can be expanded to show additional content or details, providing a dynamic user experience.
+ * It also supports a disabled state, which prevents user interaction with the item.
+ * Has host directive ExpandableItemDirective with inputs `expanded` and `id`.
+ *
+ * @see {ExpandableItemDirective}
+ */
 export declare class RichListItemComponent {
     private readonly disabledController;
     private readonly content?;
     readonly expandableItem: ExpandableItemDirective;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     /**
-     * @output expandedChange
      * Emits an event whenever the expanded state of the `RichListItemComponent` changes. This EventEmitter
      * outputs a boolean value that indicates the new expanded state of the component: `true` for expanded
      * and `false` for collapsed. This allows for external components or services to react to changes

package/components/rich-list/lib/rich-list.component.d.ts

@@ -1,10 +1,17 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/cdk/expandable";
+/**
+ * RichListComponent is designed to display a list with rich content in each item,
+ * supporting expandable functionality. It can operate in a condensed mode to save space.
+ * Has host directive ExpandableContainerDirective with an input `multiple`.
+ *
+ * @see {ExpandableContainerDirective}
+ */
 export declare class RichListComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     /**
-     * @input condensed
-     * This rich-list variant sets the vertical padding to 0 for all it's rich-list-items
+     * Determines whether the list is displayed in a condensed format.
+     * This makes the list more compact by reducing the padding and margins.
      */
     condensed: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<RichListComponent, never>;

package/components/select/lib/components/select-option/select-option.component.d.ts

@@ -1,18 +1,55 @@
 import { OnInit } from '@angular/core';
 import { OptionControl } from '@odx/angular/cdk/option-control';
 import * as i0 from "@angular/core";
+/**
+ * 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.
+ *
+ * @see {OptionControl}
+ */
 export declare class SelectOptionComponent<T = unknown> extends OptionControl<T> implements OnInit {
-    private readonly disabledController;
+    private _isDisabled;
     protected readonly selectControl: import("@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; }; }, {}, never, ["*"], true, 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;
 }

package/components/select/lib/directives/select-input-control.directive.d.ts

@@ -1,7 +1,18 @@
 import { InputControlDirective } from '@odx/angular/cdk/custom-form-control';
 import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
 import * as i0 from "@angular/core";
+/**
+ * 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}
+ */
 export declare class SelectInputControlDirective extends InputControlDirective {
+    /**
+     * Dynamic content to be displayed when no matching search results are found.
+     * This can be specified as HTML content or a string.
+     */
     notFoundContent: DynamicContent | null;
     handleDelete(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectInputControlDirective, never>;

package/components/select/lib/pipes/select-search-filter.pipe.d.ts

@@ -1,6 +1,16 @@
 import { PipeTransform } from '@angular/core';
 import { BaseSearchFilterPipe } from '@odx/angular/cdk/autocomplete-control';
 import * as i0 from "@angular/core";
+/**
+ * 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}
+ */
 export declare class SelectSearchFilterPipe extends BaseSearchFilterPipe implements PipeTransform {
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectSearchFilterPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<SelectSearchFilterPipe, "odxSelectSearchFilter", true>;

package/components/select/lib/select.component.d.ts

@@ -4,24 +4,83 @@ import { AutocompleteControl } from '@odx/angular/cdk/autocomplete-control';
 import { SelectOptionComponent } from './components';
 import { SelectInputControlDirective } from './directives';
 import * as i0 from "@angular/core";
+/**
+ * SelectComponent provides an advanced dropdown list that supports autocomplete, multiple selection,
+ * and accessibility features. It extends AutocompleteControl for seamless integration with Angular forms.
+ *
+ * @see {AutocompleteControl}
+ */
 export declare class SelectComponent<T = unknown> extends AutocompleteControl<T | null> implements AfterViewInit {
     protected searchFieldEnabled: boolean;
     protected selectedOption: SelectOptionComponent<T> | null;
     protected selectedOptionText: string | null;
     protected options?: QueryList<SelectOptionComponent<T>>;
+    /**
+     * Directive managing the search input field within the select.
+     *
+     * @type {SelectInputControlDirective}
+     */
     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;
+    /**
+     * Placeholder text for the select input when no option is selected.
+     *
+     * @type {string}
+     */
     placeholder: string;
+    /**
+     * Sets whether multiple options can be selected.
+     *
+     * @type {boolean}
+     */
     multiple: boolean;
+    /**
+     * Custom template for displaying the selected option.
+     *
+     * @type {TemplateRef<{ $implicit: T }> | null}
+     */
     selectedOptionTemplate?: TemplateRef<{
         $implicit: T;
     }> | null;
+    /**
+     * Function to determine if two options are identical, useful for detecting changes in selection.
+     *
+     * @type {IdentityMatcher<T | null>}
+     *
+     * @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: QueryList<SelectOptionComponent<T>>): void;
     protected handleQueryListOption(options: QueryList<SelectOptionComponent<T>>): void;

package/components/slider/lib/slider.directive.d.ts

@@ -1,11 +1,30 @@
 import { ElementRef } from '@angular/core';
 import * as i0 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}
+ */
 export declare class SliderDirective {
     readonly element: ElementRef<HTMLInputElement>;
+    /**
+     * Retrieves the current value of the slider.
+     */
     get value(): number;
+    /**
+     * Retrieves the maximum value of the slider. Defaults to 100 if not specified.
+     */
     get max(): number;
+    /**
+     * Retrieves the minimum value of the slider. Defaults to the native minimum if not specified.
+     */
     get min(): number;
+    /**
+     * Computes the percentage of the slider.
+     */
     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: {}; }]>;

package/components/spinbox/lib/spinbox.component.d.ts

@@ -1,14 +1,30 @@
 import { AfterViewInit, ElementRef } from '@angular/core';
 import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
 import * as i0 from "@angular/core";
+/**
+ * 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}
+ */
 export declare class SpinboxComponent extends CustomFormControl<number> implements AfterViewInit {
     private readonly takeUntilDestroyed;
     private get inputElement();
     protected decrementButton: ElementRef<HTMLButtonElement>;
     protected incrementButton: ElementRef<HTMLButtonElement>;
     readonly element: ElementRef<HTMLElement>;
+    /**
+     * The maximum allowable value for the spinbox.
+     */
     max: number;
+    /**
+     * The minimum allowable value for the spinbox.
+     */
     min: number;
+    /**
+     * The value increment or decrement step for the spinbox.
+     */
     step: number;
     constructor();
     ngAfterViewInit(): void;

package/components/switch/lib/switch.component.d.ts

@@ -1,6 +1,16 @@
 import { CheckBoxControl } from '@odx/angular/cdk/checkbox-control';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * 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}
+ */
 export 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: {}; }]>;

package/components/switch/lib/switch.validator.d.ts

@@ -1,5 +1,17 @@
 import { CheckboxRequiredValidator } from '@angular/forms';
 import * as i0 from "@angular/core";
+/**
+ * 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}
+ */
 export 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>;

package/components/tab-bar/lib/components/tab-bar-item/tab-bar-item.component.d.ts

@@ -1,6 +1,17 @@
 import { Highlightable } from '@angular/cdk/a11y';
 import { ElementRef, EventEmitter, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
 export declare class TabBarItemComponent implements Highlightable, OnInit {
     private readonly disabledController;
     private readonly tabBar;
@@ -9,10 +20,27 @@ export declare class TabBarItemComponent implements Highlightable, OnInit {
     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}
+     */
     closable: boolean;
+    /**
+     * Event emitter that fires when the tab is closed. It emits the instance of the tab item component.
+     * @type {EventEmitter<TabBarItemComponent>}
+     */
     tabClose: EventEmitter<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;

package/components/tab-bar/lib/tab-bar.component.d.ts

@@ -3,6 +3,16 @@ import { AfterViewInit, ElementRef, EventEmitter, QueryList } from '@angular/cor
 import { TabBarItemComponent } from './components';
 import { TabChangeEvent } from './models';
 import * as i0 from "@angular/core";
+/**
+ * `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.
+ */
 export declare class TabBarComponent implements AfterViewInit {
     private readonly changeDetector;
     private readonly takeUntilDestroyed;
@@ -13,12 +23,71 @@ export declare class TabBarComponent implements AfterViewInit {
     protected tabActionElements: QueryList<ElementRef<HTMLElement>>;
     protected tabs: QueryList<TabBarItemComponent>;
     readonly element: ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the tab bar has overflowed to the left.
+     *
+     * @type {boolean}
+     */
     overflowLeft: boolean;
+    /**
+     * Indicates whether the tab bar has overflowed to the right.
+     *
+     * @type {boolean}
+     */
     overflowRight: boolean;
+    /**
+     * Gets or sets the 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>
+     * ```
+     */
     set selectedIndex(value: 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: EventEmitter<TabChangeEvent>;
     ngAfterViewInit(): void;
+    /**
+     * Activates the specified tab item.
+     *
+     * @param {TabBarItemComponent | null} item - The tab item to activate. If not provided or null, the active item will be cleared.
+     *
+     * @example
+     * ```ts
+     * // Activate the first tab item
+     * tabBar.activateItem(tabItems[0]);
+     *
+     * // Clear the active item
+     * tabBar.activateItem(null);
+     * ```
+     */
     activateItem(item?: TabBarItemComponent | null): void;
+    /**
+     * Removes the specified item from the tab bar.
+     * If the removed item is the active item, it sets the previous item as the new active item.
+     *
+     * @param {TabBarItemComponent} item - The item to be removed from the tab bar.
+     */
     removeItem(item: TabBarItemComponent): void;
     protected onKeydown(event: KeyboardEvent): void;
     private updatePanelPosition;

package/components/table/lib/components/check-cell/check-cell.component.d.ts

@@ -1,10 +1,28 @@
 import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * CheckCellComponent provides a checkbox input within a table cell, allowing rows to be selected.
+ * It is designed to be used in conjunction with a table component that manages state and header interactions,
+ * particularly for functionalities like bulk actions.
+ */
 export declare class CheckCellComponent {
     private readonly table;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the checkbox within the table cell is checked.
+     * @type {boolean}
+     */
     checked: boolean;
+    /**
+     * Event emitter that triggers when the checked state changes. It emits the new state of the checkbox.
+     * @type {EventEmitter<boolean>}
+     */
     checkedChange: EventEmitter<boolean>;
+    /**
+     * Updates the checked state of the checkbox and notifies the parent table component, typically to update
+     * the state of a header checkbox or other related components.
+     * @param {boolean} e - The new checked state.
+     */
     update(e: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CheckCellComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CheckCellComponent, "td[odx-table-cell][checked]", never, { "checked": { "alias": "checked"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;