@odx/angular 12.26.0 → 13.0.0

package/cdk/event-plugins/index.d.ts

@@ -1,3 +1,187 @@
-export * from './lib/event-plugins.config';
-export * from './lib/models';
-export * from './lib/plugins';
+import * as i0 from '@angular/core';
+import { Provider, EnvironmentProviders, NgZone } from '@angular/core';
+import { EventManager } from '@angular/platform-browser';
+
+declare const EVENT_PLUGINS: Provider[];
+/**
+ * Provides a set of custom event plugins to Angular's event handling system. This function
+ * registers custom event plugins like `DebounceEventPlugin` and `DeferEventPlugin`, enhancing
+ * the capabilities of Angular's native event management. By using `EVENT_MANAGER_PLUGINS`, these
+ * plugins are integrated into Angular's event system and can be utilized in templates and components
+ * to handle events with custom behaviors such as debouncing or deferring event execution.
+ *
+ * @example
+ * Registering the event plugins in an Angular module:
+ * ```ts
+ * @NgModule({
+ *   imports: [
+ *     BrowserModule,
+ *     BrowserAnimationsModule,
+ *     // other imports...
+ *   ],
+ *   declarations: [AppComponent],
+ *   providers: [
+ *     provideEventPlugins(),
+ *   ],
+ *   bootstrap: [AppComponent],
+ * })
+ * export class AppModule {}
+ * ```
+ * Assuming `DebounceEventPlugin` modifies event names with a `.debounce` modifier:
+ * ```html
+ * <button (click.debounce)="handleDebouncedClick($event)">Click Me</button>
+ *  ```
+ * Assuming `DeferEventPlugin` modifies event names with a `.defer` modifier:
+ * ```html
+ * <div (mouseenter.defer)="handleDeferredMouseEnter($event)"></div>
+ * ```
+ *
+ * @returns {EnvironmentProviders} - A configuration object for Angular's DI system, to be used with `makeEnvironmentProviders`.
+ */
+declare function provideEventPlugins(): EnvironmentProviders;
+
+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>
+ * ```
+ */
+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;
+}
+
+/**
+ * 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...">
+ * ```
+ */
+declare class DebounceEventPlugin extends EventPlugin {
+    readonly modifier: RegExp;
+    addEventListener(element: HTMLElement, eventName: string, originalHandler: EventListener): Function;
+    private createHandler;
+    private runOutsideAngular;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebounceEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DebounceEventPlugin>;
+}
+
+/**
+ * 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.
+ */
+declare class DeferEventPlugin extends EventPlugin {
+    readonly modifier: RegExp;
+    addEventListener(element: HTMLElement, eventName: string, originalHandler: EventListener): Function;
+    private createHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeferEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeferEventPlugin>;
+}
+
+export { DebounceEventPlugin, DeferEventPlugin, EVENT_PLUGINS, EventPlugin, provideEventPlugins };

package/cdk/expandable/index.d.ts

@@ -1,4 +1,169 @@
-export * from './lib/directives';
-export * from './lib/expandable.module';
-export * from './lib/expandable.tokens';
-export * from './lib/facade';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, InjectionToken } from '@angular/core';
+
+interface ExpandableItem {
+    id: string;
+    expanded: boolean;
+    collapse(): void;
+    expand(): void;
+    toggle(): void;
+    addChild(container: ExpandableContainer): void;
+    removeChild(container: ExpandableContainer): void;
+}
+
+interface ExpandableContainer {
+    multiple: boolean;
+    collapseAll(): void;
+    collapse(item: ExpandableItem): void;
+    expand(item: ExpandableItem): void;
+    toggle(item: ExpandableItem): void;
+    isExpanded(item: ExpandableItem): boolean;
+    hasExpandedItem(): boolean;
+}
+
+/**
+ * `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.
+ */
+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.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    multiple: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Collapses all the expanded items within the expandable container.
+     */
+    collapseAll(): void;
+    /**
+     * Collapses the specified item.
+     *
+     * @param {ExpandableItem} 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 {ExpandableItem} 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 {ExpandableItem} item - The item to toggle the expansion state for.
+     * @param {boolean} 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 {ExpandableItem} 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>;
+    static ngAcceptInputType_multiple: unknown;
+}
+
+/**
+ * `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.
+ */
+declare class ExpandableItemDirective implements ExpandableItem {
+    private readonly changeDetectorRef;
+    private readonly childContainers;
+    private _expanded;
+    /**
+     * Container which can be set manually.
+     */
+    container: ExpandableContainer | null;
+    /** Unique identifier for the expandable item.
+     *
+     * @type {string}
+     */
+    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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExpandableItemDirective, "[odxExpandableItem]", ["odxExpandableItem"], { "container": { "alias": "container"; "required": false; }; "id": { "alias": "id"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_expanded: unknown;
+}
+
+declare class ExpandableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExpandableModule, never, [typeof ExpandableContainerDirective, typeof ExpandableItemDirective], [typeof ExpandableContainerDirective, typeof ExpandableItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExpandableModule>;
+}
+
+declare const ODX_EXPANDABLE_CONTAINER: InjectionToken<ExpandableContainer>;
+declare const ODX_EXPANDABLE_ITEM: InjectionToken<ExpandableItem>;
+
+export { ExpandableContainerDirective, ExpandableItemDirective, ExpandableModule, ODX_EXPANDABLE_CONTAINER, ODX_EXPANDABLE_ITEM };
+export type { ExpandableContainer, ExpandableItem };

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

@@ -1 +1,70 @@
-export * from './lib/option-control';
+import * as rxjs from 'rxjs';
+import { Highlightable } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import { ChangeDetectorRef, ElementRef } 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.
+ *
+ * @param {T} - The type of the value.
+ *
+ * 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.
+ */
+declare abstract class OptionControl<T> implements Highlightable {
+    protected readonly takeUntilDestroyed: <T_1>() => 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}
+     */
+    abstract 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionControl<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OptionControl<any>, never, never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { OptionControl };

package/cdk/radio-group-control/index.d.ts

@@ -1,3 +1,74 @@
-export * from './lib/radio-control.directive';
-export * from './lib/radio-group-control.directive';
-export * from './lib/radio-group-control.module';
+import * as _odx_angular_cdk_radio_group_control from '@odx/angular/cdk/radio-group-control';
+import * as i3 from '@odx/angular';
+import { DisabledController, ReadonlyController } from '@odx/angular';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
+
+/**
+ * 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.
+ *
+ * @template T - The type of the value.
+ */
+declare class RadioControlDirective<T = unknown> {
+    protected readonly disabledController: DisabledController | null;
+    protected readonly readonlyController: ReadonlyController | null;
+    protected readonly radioGroupControl: _odx_angular_cdk_radio_group_control.RadioGroupControlDirective<unknown>;
+    /**
+     * The value of the radio control.
+     *
+     * @type {T | null}
+     * @default null
+     */
+    value: T | null;
+    /**
+     * The `aria-checked` attribute value.
+     *
+     * @type {string}
+     */
+    get ariaChecked(): string;
+    /**
+     * Gets a value indicating whether the radio control is active.
+     *
+     * @type {boolean}
+     */
+    get isActive(): boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioControlDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioControlDirective<any>, "[odxRadioControl]", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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.
+ *
+ * @template T - The type of the value.
+ */
+declare class RadioGroupControlDirective<T = unknown> extends CustomFormControl<T | null> {
+    private readonly hostElement;
+    constructor();
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupControlDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioGroupControlDirective<any>, "[odxRadioGroupControl]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RadioGroupControlModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupControlModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RadioGroupControlModule, never, [typeof RadioGroupControlDirective, typeof RadioControlDirective], [typeof i3.CoreModule, typeof RadioGroupControlDirective, typeof RadioControlDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RadioGroupControlModule>;
+}
+
+export { RADIO_GROUP_CONTROL, RadioControlDirective, RadioGroupControlDirective, RadioGroupControlModule };

package/cdk/scrollable/index.d.ts

@@ -1 +1,57 @@
-export * from './lib/scrollable.service';
+import * as _angular_core from '@angular/core';
+import { ElementRef, OnDestroy } from '@angular/core';
+
+interface ScrollableItem {
+    element: ElementRef<HTMLElement>;
+}
+/**
+ * Service to manage scrollable items within a container, providing functionality to observe item visibility
+ * and navigate through them.
+ */
+declare class ScrollableService implements OnDestroy {
+    private intersectionObserver?;
+    private scrollContainer?;
+    /**
+     * References to the next and previous scrollable items.
+     *
+     * @type {HTMLElement | null}
+     */
+    readonly nextItem: _angular_core.WritableSignal<HTMLElement | null>;
+    /**
+     * References to the previous scrollable item.
+     *
+     * @type {HTMLElement | null}
+     */
+    readonly prevItem: _angular_core.WritableSignal<HTMLElement | null>;
+    /** List of currently visible items within the scroll container.
+     *
+     * @type {HTMLElement[]}
+     */
+    readonly visibleItems: _angular_core.WritableSignal<HTMLElement[]>;
+    ngOnDestroy(): void;
+    /**
+     * Starts observing the scrollable items within the specified container.
+     *
+     * @param {ElementRef<HTMLElement>} scrollContainer - The container element that holds the scrollable items.
+     * @param {readonly ScrollableItem[]} items - The list of scrollable items to observe.
+     */
+    observe(scrollContainer: ElementRef<HTMLElement>, items: readonly ScrollableItem[]): void;
+    /**
+     * Scrolls the container in the specified direction.
+     *
+     * @param {'next' | 'prev'} direction - The direction to scroll ('next' for right, 'prev' for left).
+     */
+    scroll(direction?: 1 | -1): void;
+    /**
+     * Scrolls the active item into view within the scroll container.
+     *
+     * @param {HTMLElement | null} activeItem - The currently active item to scroll into view.
+     */
+    scrollActiveItemIntoHorizontalView(activeItem: HTMLElement | null): void;
+    private observeVisibility;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollableService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScrollableService>;
+}
+
+export { ScrollableService };
+export type { ScrollableItem };

package/components/accordion/index.d.ts

@@ -1,4 +1,91 @@
-export * from './lib/accordion.component';
-export * from './lib/accordion.module';
-export * from './lib/components/accordion-item/accordion-item.component';
-export * from './lib/directives';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@odx/angular/cdk/expandable';
+import { ExpandableItemDirective } from '@odx/angular/cdk/expandable';
+import * as i4 from '@odx/angular';
+
+/**
+ * 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.
+ */
+declare class AccordionComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "odx-accordion", never, {}, {}, never, ["odx-accordion-item"], true, [{ directive: typeof i1.ExpandableContainerDirective; inputs: { "multiple": "multiple"; }; outputs: {}; }]>;
+}
+
+/**
+ * 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.
+ */
+declare class AccordionItemComponent {
+    private readonly disabledController;
+    protected readonly expandableItem: ExpandableItemDirective;
+    protected readonly expandableBlock: i0.Signal<ElementRef<any> | undefined>;
+    readonly element: ElementRef<HTMLElement>;
+    /**
+     * The title for the accordion item. This is an `InputSignal`.
+     * @default null
+     */
+    title: i0.InputSignal<string | null>;
+    /**
+     * Emits when the expanded state of the accordion item changes.
+     * This is an `OutputEmitterRef`.
+     *
+     * The emitted value is the new expanded state.
+     */
+    expandedChange: i0.OutputEmitterRef<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 {string} 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 {string} The slot ID.
+     */
+    get slotId(): string;
+    protected onTransitionEnd({ target, propertyName }: TransitionEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "odx-accordion-item", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, { "expandedChange": "expandedChange"; }, never, ["odx-accordion-item-title", "*"], true, [{ directive: typeof i1.ExpandableItemDirective; inputs: { "expanded": "expanded"; "id": "id"; }; outputs: {}; }]>;
+}
+
+/**
+ * Directive for the title of an accordion item.
+ */
+declare class AccordionItemTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionItemTitleDirective, "odx-accordion-item-title", never, {}, {}, never, never, true, never>;
+}
+
+declare class AccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AccordionModule, never, [typeof AccordionComponent, typeof AccordionItemComponent, typeof AccordionItemTitleDirective], [typeof i4.CoreModule, typeof AccordionComponent, typeof AccordionItemComponent, typeof AccordionItemTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AccordionModule>;
+}
+
+export { AccordionComponent, AccordionItemComponent, AccordionItemTitleDirective, AccordionModule };