@odx/angular 6.0.0 → 6.0.1

package/cdk/event-plugins/lib/models/event-plugin.d.ts

@@ -4,13 +4,70 @@ type EventManagerArg = ConstructorParameters<typeof EventManager>[0][0];
 type EventManagerPlugin = {
     [K in keyof EventManagerArg]: EventManagerArg[K];
 };
+/**
+ * An abstract class for implementing custom event plugins in Angular. This class provides
+ * the core functionality required to create a custom event listener with specific behavior,
+ * allowing developers to extend Angular's native event handling capabilities.
+ *
+ * @example
+ * Extending EventPlugin to create a custom event plugin:
+ * ```ts
+ * @Injectable()
+ * class CustomEventPlugin extends EventPlugin {
+ *   public readonly modifier = /custom/;
+ *
+ *   public addEventListener(element: HTMLElement, eventName: string, handler: EventListener): Function {
+ *     // Custom logic for adding an event listener
+ *   }
+ * }
+ * ```
+ *
+ * ```html
+ * <div (click.custom)="handleClick($event)"></div>
+ * ```
+ */
 export declare abstract class EventPlugin implements EventManagerPlugin {
     protected abstract readonly modifier: RegExp;
+    /**
+     * The event manager for handling events.
+     *
+     * @type {EventManager}
+     */
     manager: EventManager;
+    /**
+     * Adds an event listener to the given element.
+     *
+     * @param {HTMLElement} element - The element to attach the event listener to.
+     * @param {string} eventName - The name of the event.
+     * @param {EventListener} handler - The event listener function.
+     * @returns {Function} - A function that can be called to remove the event listener.
+     */
     abstract addEventListener(element: HTMLElement, eventName: string, handler: EventListener): Function;
+    /**
+     * Adds a global event listener.
+     *
+     * @returns {Function} - A function that does nothing.
+     */
     addGlobalEventListener(): Function;
+    /**
+     * Checks if the event plugin supports the given event name.
+     *
+     * @param {string} eventName - The name of the event.
+     * @returns {boolean} - `true` if the event plugin supports the event, `false` otherwise.
+     */
     supports(eventName: string): boolean;
+    /**
+     * Gets the NgZone instance from the event manager.
+     *
+     * @returns {NgZone} - The NgZone instance.
+     */
     protected getZone(): NgZone;
+    /**
+     * Tears down the event listener.
+     *
+     * @param {Function | null} listener - The event listener function.
+     * @returns {Function} - A function that can be called to clean up the listener.
+     */
     protected teardown(listener: Function | null): () => void;
 }
 export {};

package/cdk/event-plugins/lib/plugins/debounce-event-plugin.d.ts

@@ -1,5 +1,37 @@
 import { EventPlugin } from '../models';
 import * as i0 from "@angular/core";
+/**
+ * A service that extends `EventPlugin` for debouncing events. This service wraps event listeners
+ * and ensures that they are triggered no more than once per specified delay period. It is
+ * particularly useful for handling events that fire frequently, such as mouse movements
+ * or keystrokes, in a performant manner.
+ *
+ * The delay period can be specified directly in the event name using the syntax
+ * `(eventName.debounce.delay)`, where `delay` is the debounce duration in milliseconds.
+ * If no delay is specified, a default delay of 250 milliseconds is used.
+ *
+ * @example
+ * Provide the `DebounceEventPlugin` in an Angular module:
+ * ```ts
+ * @NgModule({
+ *  providers: [
+ *   ...
+ *   provideEventPlugins(),
+ *   ...
+ *  ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * In a component template, apply the debounce modifier to an event, specifying a custom delay:
+ * ```html
+ * <button (click.debounce.400)="handleClick($event)"></button>
+ * ```
+ * In a component template, apply the debounce modifier with the default delay:
+ * ```html
+ * <input (keyup.debounce)="onKeyUp($event)" placeholder="Type here...">
+ * ```
+ */
 export declare class DebounceEventPlugin extends EventPlugin {
     readonly modifier: RegExp;
     addEventListener(element: HTMLElement, eventName: string, originalHandler: EventListener): Function;

package/cdk/event-plugins/lib/plugins/defer-event-plugin.d.ts

@@ -1,5 +1,29 @@
 import { EventPlugin } from '../models';
 import * as i0 from "@angular/core";
+/**
+ * A service that extends `EventPlugin` to allow event handlers to be deferred until the end of the current call stack.
+ * This can improve performance by avoiding triggering Angular's change detection unnecessarily.
+ *
+ * @example
+ * Provide the `DeferEventPlugin` in an Angular module:
+ * ```ts
+ * @NgModule({
+ *  providers: [
+ *   ...
+ *   provideEventPlugins(),
+ *   ...
+ *  ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * In your Angular component:
+ * ```html
+ * <button (click.defer)="handleClick($event)"></button>
+ * ```
+ *
+ * The `.defer` modifier in the event name `click.defer` indicates that the event handler should be deferred.
+ */
 export declare class DeferEventPlugin extends EventPlugin {
     readonly modifier: RegExp;
     addEventListener(element: HTMLElement, eventName: string, originalHandler: EventListener): Function;

package/cdk/expandable/lib/directives/expandable-container.directive.d.ts

@@ -1,18 +1,59 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import type { ExpandableContainer, ExpandableItem } from '../facade';
 import * as i0 from "@angular/core";
+/**
+ * `ExpandableContainerDirective` provides a container for managing a group of expandable items,
+ * allowing them to expand or collapse. It supports the functionality to either allow multiple
+ * items to be expanded simultaneously or restrict to a single item at a time.
+ *
+ * This directive uses Angular's dependency injection to optionally inject a parent `ExpandableItem` or `ExpandableContainer`,
+ * enabling nested expandable structures. The `multiple` property can be set to dictate the expand/collapse behavior.
+ */
 export declare class ExpandableContainerDirective implements ExpandableContainer, OnInit, OnDestroy {
     private readonly expandedItems;
     private readonly parentItem;
     private readonly parentContainer;
+    /**
+     * Determines whether multiple items can be expanded within the container.
+     */
     multiple: boolean;
     ngOnInit(): void;
     ngOnDestroy(): void;
+    /**
+     * Collapses all the expanded items within the expandable container.
+     */
     collapseAll(): void;
+    /**
+     * Collapses the specified item.
+     *
+     * @param item - The item to collapse.
+     */
     collapse(item: ExpandableItem): void;
+    /**
+     * Expands the specified item.
+     * If `multiple` is set to `false`, it collapses all other items before expanding the specified item.
+     * @param item - The item to expand.
+     */
     expand(item: ExpandableItem): void;
+    /**
+     * Toggles the expansion state of the specified item.
+     * If `forceState` is provided, it will set the expansion state to the specified value.
+     * If `forceState` is not provided, it will toggle the expansion state of the item.
+     *
+     * @param item - The item to toggle the expansion state for.
+     * @param forceState - Optional. The desired expansion state to set for the item.
+     */
     toggle(item: ExpandableItem, forceState?: boolean): void;
+    /**
+     * Checks if the specified item is expanded.
+     * @param item - The item to check.
+     * @returns `true` if the item is expanded, `false` otherwise.
+     */
     isExpanded(item: ExpandableItem): boolean;
+    /**
+     * Checks if there is any expanded item.
+     * @returns {boolean} True if there is at least one expanded item, false otherwise.
+     */
     hasExpandedItem(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableContainerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ExpandableContainerDirective, "[odxExpandableContainer]", ["odxExpandableContainer"], { "multiple": { "alias": "multiple"; "required": false; }; }, {}, never, never, true, never>;

package/cdk/expandable/lib/directives/expandable-item.directive.d.ts

@@ -1,17 +1,64 @@
 import type { ExpandableContainer, ExpandableItem } from '../facade';
 import * as i0 from "@angular/core";
+/**
+ * `ExpandableItemDirective` allows you to manage the expansion state of an item within an expandable container, such as an accordion or a nested list. It provides methods to expand, collapse, and toggle the item, and automatically registers itself with a parent expandable container if one is available.
+ *
+ * You can control the expanded state programmatically by binding to the `expanded` property.
+ */
 export declare class ExpandableItemDirective implements ExpandableItem {
     private readonly changeDetectorRef;
     private readonly childContainers;
     private readonly container;
     private _expanded;
+    /** Unique identifier for the expandable item. */
     id: string;
+    /**
+     * Controls the expanded state of the item.
+     *
+     * @param {boolean} value - When `true`, expands the item; when `false`, collapses the item.
+     *
+     * @example
+     * Bind to the expanded state:
+     * ```html
+     * <div odxExpandableItem [expanded]="isItemExpanded"></div>
+     * ```
+     */
     set expanded(value: boolean);
+    /**
+     * Gets a value indicating whether the item is expanded.
+     * If the item is contained within a container, it checks the container's `isExpanded` method.
+     * Otherwise, it returns the value of the `_expanded` property.
+     *
+     * @type {boolean} `true` if the item is expanded; otherwise, `false`.
+     */
     get expanded(): boolean;
+    /**
+     * Toggles the expansion state of the item, optionally forcing a specific state.
+     *
+     * @param {boolean} forceState - When provided, forces the expansion state to the specified value.
+     */
     toggle(forceState?: boolean): void;
+    /** Expands the item.
+     *
+     * @returns {void}
+     */
     expand(): void;
+    /** Collapses the item.
+     *
+     * @returns {void}
+     */
     collapse(): void;
+    /** Adds a child container to the item.
+     *
+     * @param {ExpandableContainer} container - The child container to add.
+     * @returns {void}
+     */
     addChild(container: ExpandableContainer): void;
+    /** Removes a child container from the item.
+     *
+     * @param {ExpandableContainer} container - The child container to remove.
+     * @returns {void}
+     */
     removeChild(container: ExpandableContainer): void;
     private closeAllChildren;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableItemDirective, never>;

package/cdk/option-control/lib/option-control.d.ts

@@ -1,14 +1,61 @@
 import { Highlightable } from '@angular/cdk/a11y';
 import { ChangeDetectorRef, ElementRef } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * `OptionControl` is an abstract directive that serves as a base class for implementing selectable options in a dropdown
+ * list or a similar component. It integrates with CDK's `Highlightable` interface to provide keyboard navigation support.
+ *
+ * This base class handles the visual feedback for active and selected states and provides a structure for defining
+ * how an option is selected.
+ *
+ * Extend `OptionControl` to create a concrete option component:
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'my-option',
+ *   templateUrl: './my-option.component.html',
+ *   providers: [{ provide: OptionControl, useExisting: forwardRef(() => MyOptionComponent) }],
+ * })
+ * class MyOptionComponent extends OptionControl<MyDataType> {
+ *   @Input() override value: MyDataType | null = null;
+ *
+ *   protected override selectOption(): void {
+ *     // Custom logic for when this option is selected
+ *   }
+ * }
+ * ```
+ *
+ * Implement `selectOption` in subclasses to define what happens when an option is selected, such as updating a model
+ * or closing a dropdown.
+ */
 export declare abstract class OptionControl<T> implements Highlightable {
     protected readonly takeUntilDestroyed: <T_1>() => import("rxjs").MonoTypeOperatorFunction<T_1>;
     protected readonly cdr: ChangeDetectorRef;
     protected isActive: boolean;
+    /**
+     * Represents the value of the option control.
+     *
+     * @type {T} - The type of the value.
+     */
     value: T | null;
     readonly element: ElementRef<HTMLElement>;
+    /**
+     * Sets the active styles for the option control.
+     *
+     * @returns {void}
+     */
     setActiveStyles(): void;
+    /**
+     * Sets the inactive styles for the option control.
+     *
+     * @returns {void}
+     */
     setInactiveStyles(): void;
+    /**
+     * Retrieves the label of the option control.
+     *
+     * @returns {string} - The label of the option control.
+     */
     getLabel(): string;
     protected abstract selectOption(): void;
     protected select(event: Event): void;

package/cdk/radio-group-control/lib/radio-control.directive.d.ts

@@ -1,5 +1,13 @@
 import { DisabledController, ReadonlyController } from '@odx/angular';
 import * as i0 from "@angular/core";
+/**
+ * A directive that provides radio button functionality within a radio group.
+ * It tracks the active state based on the current value of the parent `odxRadioGroupControl`.
+ *
+ * This directive integrates with Angular Forms through `DisabledController` and `ReadonlyController` directives,
+ * enabling form control states like disabled and readonly. It automatically updates its classes
+ * to reflect these states and the active (checked) state.
+ */
 export declare class RadioControlDirective<T = unknown> {
     protected readonly disabledController: DisabledController | null;
     protected readonly readonlyController: ReadonlyController | null;

package/cdk/radio-group-control/lib/radio-group-control.directive.d.ts

@@ -2,6 +2,17 @@ import { InjectionToken } from '@angular/core';
 import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
 import * as i0 from "@angular/core";
 export declare const RADIO_GROUP_CONTROL: InjectionToken<RadioGroupControlDirective<unknown>>;
+/**
+ * A directive that provides radio group functionality for its child radio button components.
+ * It tracks the value and selection state of a group of `odxRadioControl` directives.
+ *
+ * This directive extends `CustomFormControl` to integrate seamlessly with Angular Forms API,
+ * providing form control methods and properties. It supports form control states like disabled
+ * and readonly through `DisabledController` and `ReadonlyController` directives.
+ *
+ * It uses Angular's dependency injection to provide itself as `RADIO_GROUP_CONTROL` token,
+ * allowing child radio buttons to communicate with the radio group directive.
+ */
 export declare class RadioGroupControlDirective<T = unknown> extends CustomFormControl<T | null> {
     private readonly hostElement;
     constructor();

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

@@ -1,5 +1,13 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/cdk/expandable";
+/**
+ * Represents an accordion component.
+ * Has host directive ExpandableContainerDirective
+ *
+ * @see {ExpandableContainerDirective}
+ *
+ * You can manage the expansion state of the accordion items by using the `ExpandableContainerDirective` methods.
+ */
 export declare class AccordionComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;

package/components/accordion/lib/components/accordion-item/accordion-item.component.d.ts

@@ -2,17 +2,53 @@ 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";
+/**
+ * Represents an item in an accordion component.
+ * Has host directive ExpandableItemDirective
+ *
+ * @see {ExpandableItemDirective}
+ *
+ * You can control the accordion item's expansion state through the ExpandableItemDirective methods.
+ */
 export declare class AccordionItemComponent {
     private readonly disabledController;
     protected readonly expandableItem: ExpandableItemDirective;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The title of the accordion item.
+     *
+     * @remarks
+     * This property is optional and can be a string or null.
+     */
     title?: string | null;
+    /**
+     * Event emitter for the expanded state change of the accordion item.
+     * Emits a boolean value indicating whether the item is expanded or not.
+     */
     expandedChange: EventEmitter<boolean>;
+    /**
+     * Gets a value indicating whether the accordion item is disabled.
+     * @returns {boolean} True if the accordion item is disabled, false otherwise.
+     */
     get isDisabled(): boolean;
+    /**
+     * Gets a value indicating whether the accordion item is expanded.
+     * @returns {boolean} True if the accordion item is expanded, false otherwise.
+     */
     get isExpanded(): boolean;
+    /**
+     * Gets the ID of the title element for accessibility purposes.
+     * The ID is generated by appending "-title" to the ID of the expandable item.
+     * @returns The ID of the title element.
+     */
     get titleId(): string;
+    /**
+     * Gets the slot ID for the accordion item.
+     * The slot ID is generated by appending "-slot" to the ID of the expandable item.
+     * @returns The slot ID.
+     */
     get slotId(): string;
-    onAnimationEnd(): void;
+    protected onAnimationEnd(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "odx-accordion-item", never, { "title": { "alias": "title"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, ["odx-accordion-item-title", "*"], true, [{ directive: typeof i1.ExpandableItemDirective; inputs: { "expanded": "expanded"; "id": "id"; }; outputs: {}; }]>;
 }

package/components/accordion/lib/directives/accordion-item-title.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Directive for the title of an accordion item.
+ */
 export declare class AccordionItemTitleDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemTitleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionItemTitleDirective, "odx-accordion-item-title", never, {}, {}, never, never, true, never>;

package/components/action-group/action-group.component.d.ts

@@ -1,6 +1,12 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents an action group component.
+ */
 export declare class ActionGroupComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the action group should be displayed in reverse order.
+     */
     reverse: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<ActionGroupComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ActionGroupComponent, "odx-action-group", never, { "reverse": { "alias": "reverse"; "required": false; }; }, {}, never, ["[odxButton], ng-template"], true, never>;

package/components/area-header/area-header.component.d.ts

@@ -1,7 +1,15 @@
 import { AreaHeaderSize } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Represents the AreaHeaderComponent.
+ */
 export declare class AreaHeaderComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The size of the area header.
+     *
+     * @see {AreaHeaderSize}
+     */
     size: AreaHeaderSize;
     static ɵfac: i0.ɵɵFactoryDeclaration<AreaHeaderComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AreaHeaderComponent, "odx-area-header", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, ["button[odxNavigationBack], a[odxNavigationBack]", "odx-avatar", "*", "odx-area-header-subtitle", "odx-area-header-content"], true, never>;

package/components/area-header/directives/area-header-content.directive.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Directive for the content of the area header.
+ */
 export declare class AreaHeaderContentDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<AreaHeaderContentDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AreaHeaderContentDirective, "odx-area-header-content", never, {}, {}, never, never, true, never>;

package/components/area-header/directives/area-header-subtitle.directive.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Directive for displaying a subtitle in the area header component.
+ */
 export declare class AreaHeaderSubtitleDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<AreaHeaderSubtitleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AreaHeaderSubtitleDirective, "odx-area-header-subtitle", never, {}, {}, never, never, true, never>;

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

@@ -5,6 +5,15 @@ import { AutocompleteOptionComponent } from './components';
 import { AutocompleteInputControlDirective } from './directives';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * Represents an autocomplete component that provides user interface for a dropdown list to select from as users type.
+ * It extends `AutocompleteControl`, integrating custom logic for handling keyboard and mouse events,
+ * managing the dropdown state, and updating the associated search field.
+ *
+ * @see {AutocompleteControl}
+ *
+ * @template T The type of the value handled by the autocomplete.
+ */
 export declare class AutocompleteComponent<T = unknown> extends AutocompleteControl<T | null> implements AfterViewInit {
     private readonly defaultActiveOptionIndex;
     protected readonly clickOutsideDirective: ClickOutsideDirective;
@@ -12,7 +21,15 @@ export declare class AutocompleteComponent<T = unknown> extends AutocompleteCont
     searchField?: AutocompleteInputControlDirective;
     readonly dropdownOpenTriggers: never[];
     ngAfterViewInit(): void;
+    /**
+     * Selects an option, updates the value, updates the search field display, emits the selected value, and closes the dropdown.
+     *
+     * @param option The option component to select. If the option is undefined or its value is undefined, no action is taken.
+     */
     selectOption(option?: AutocompleteOptionComponent<T> | null): void;
+    /**
+     * Resets the search field to its initial state and updates the value of the autocomplete to an empty string or initial value.
+     */
     resetSearchField(): void;
     protected handleQueryListOption(options: QueryList<AutocompleteOptionComponent<T>>): void;
     protected handleSearchFieldChanges(): void;

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

@@ -2,7 +2,15 @@ import { AvatarSize, AvatarVariant } from './models';
 import * as i0 from "@angular/core";
 export declare class AvatarComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The size of the avatar.
+     * @see {AvatarSize}
+     */
     size?: AvatarSize | null;
+    /**
+     * The variant of the avatar.
+     * @see {AvatarVariant}
+     */
     variant?: AvatarVariant | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AvatarComponent, "odx-avatar", never, { "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;

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

@@ -1,9 +1,19 @@
 import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
 import { BadgeVariant } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Represents a badge component.
+ */
 export declare class BadgeComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the badge should have a contrast effect.
+     */
     contrast: boolean;
+    /**
+     * The variant of the badge.
+     * @see {BadgeVariant}
+     */
     variant: BadgeVariant;
     value?: DynamicTextContent | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;

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

@@ -9,10 +9,25 @@ export declare class BadgeDirective implements BadgeComponent, OnChanges, OnDest
     private readonly injector;
     private badgeRef;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The value of the badge directive.
+     * @see {DynamicTextContent}
+     */
     value?: DynamicTextContent | null;
+    /**
+     * Indicates whether the badge should have a contrast effect.
+     */
     contrast: boolean;
+    /**
+     * The position of the badge.
+     * @see {Position}
+     */
     position: Position;
     offset: number;
+    /**
+     * The variant of the badge.
+     * @see {BadgeVariant}
+     */
     variant: BadgeVariant;
     ngOnChanges(): void;
     ngOnDestroy(): void;

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

@@ -1,4 +1,11 @@
 import * as i0 from "@angular/core";
+/**
+ * The `BarComponent` serves as a UI container component, typically used for presenting navigational bars,
+ * toolbars, or information bars within an application. Its design is easily customizable through the use of CSS classes.
+ *
+ * This component is standalone, meaning it can be used independently of other components without requiring explicit imports
+ * of other modules, making it easy to include wherever a bar-like structure is needed in the application.
+ */
 export declare class BarComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BarComponent, never>;

package/components/bar/lib/directives/bar-button.directive.d.ts

@@ -1,6 +1,9 @@
 import { DisabledController } from '@odx/angular';
 import { BarButtonVariant } from '../models/bar-button-variant';
 import * as i0 from "@angular/core";
+/**
+ * Represents a directive for a bar button.
+ */
 export declare class BarButtonDirective {
     protected readonly disabledController: DisabledController | null;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;

package/components/bar/lib/directives/bar-label.directive.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents a directive for displaying labels in a bar component.
+ */
 export declare class BarLabelDirective {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BarLabelDirective, never>;

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

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents a breadcrumbs component.
+ */
 export declare class BreadcrumbsComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsComponent, never>;

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

@@ -1,9 +1,19 @@
 import { ButtonSize, ButtonVariant } from './models';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * ButtonComponent is a customizable button element that supports various sizes and styles.
+ * It uses the `WithDisabledState` host directive to provide disabled state management.
+ *
+ * @see {WithDisabledState}
+ */
 export declare class ButtonComponent {
     readonly element: import("@angular/core").ElementRef<HTMLButtonElement | HTMLLinkElement>;
     readonly type: string | null;
+    /**
+     * The variant of the button.
+     * @see {ButtonVariant}
+     */
     variant?: ButtonVariant | null;
     size?: ButtonSize | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;