@odx/angular 6.0.0 → 6.1.0

package/components/table/lib/components/header-title/header-title.component.d.ts

@@ -3,22 +3,54 @@ import { FormControl, FormGroup } from '@angular/forms';
 import { SortStatus, TableHeaderCell } from '../../models';
 import { TableSortVariant } from '../../models/sort-variant';
 import * as i0 from "@angular/core";
+/**
+ * HeaderTitleComponent provides the functionality for a table header cell, including sorting and checkbox
+ * operations if applicable. It handles changes in sort state and emits relevant events to the table component
+ * to manage sorting and selection state across the table.
+ */
 export declare class HeaderTitleComponent implements OnInit {
     private readonly table;
     private readonly cdr;
     private readonly takeUntilDestroyed;
     private sortStatus;
+    /**
+     * The header cell item containing metadata like column name, sortability, and whether it should include a checkbox.
+     * @see {TableHeaderCell}
+     */
     item: TableHeaderCell;
-    test: boolean;
+    /**
+     * FormGroup to manage the checkbox state within the header.
+     */
     checkForm: FormGroup<{
         check: FormControl<boolean | null>;
     }>;
+    /**
+     * Computes and returns the current sort status of the column associated with this header.
+     */
     get getSortStatus(): SortStatus;
+    /**
+     * Returns the icon or indicator for the current sorting status (ascending, descending, unsorted).
+     */
     get sortIcon(): TableSortVariant;
+    /**
+     * Toggles the sorting status of the column and informs the table component of the change.
+     */
     sortColumn(): void;
+    /**
+     * Resets the sort status to unsorted.
+     */
     clearSortStatus(): void;
+    /**
+     * Returns the number of selected items in the column, used to determine checkbox state.
+     */
     get selected(): number;
+    /**
+     * Updates the component view, usually after a state change.
+     */
     check(): void;
+    /**
+     * Determines whether the checkbox should be marked as checked.
+     */
     get checked(): boolean;
     ngOnInit(): void;
     private checkBoxListener;

package/components/table/lib/directives/table-cell.directive.d.ts

@@ -1,4 +1,8 @@
 import * as i0 from "@angular/core";
+/**
+ * TableCellDirective enhances an HTML td element by providing a role attribute with a value of "cell".
+ * This directive is used to define a cell within a table.
+ */
 export declare class TableCellDirective {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;

package/components/table/lib/directives/table-row.directive.d.ts

@@ -1,4 +1,8 @@
 import * as i0 from "@angular/core";
+/**
+ * TableRowDirective enhances an HTML tr element by providing a role attribute with a value of "row".
+ * This directive is used to define a row within a table.
+ */
 export declare class TableRowDirective {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDirective, never>;

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

@@ -3,23 +3,59 @@ import { FormGroup } from '@angular/forms';
 import { HeaderTitleComponent } from './components/header-title/header-title.component';
 import { SortStatus, TableHeaderCell, TableVariant } from './models';
 import * as i0 from "@angular/core";
+/**
+ * TableComponent is a dynamic table structure built for displaying complex data sets with sorting, filtering,
+ * and checkable functionality. It provides configuration options through various inputs that allow the
+ * customization of table behavior and presentation.
+ *
+ * This component is highly modular, integrating with other components such as `HeaderTitleComponent` for header
+ * management, and using Angular forms for dynamic data filtering.
+ */
 export declare class TableComponent<T> implements OnInit {
     private readonly takeUntilDestroyed;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Specifies the table variant for CSS styling.
+     * @see {TableVariant}
+     */
     variant?: TableVariant | null;
+    /**
+     * Data array of type T that the table displays.
+     */
     data: T[];
+    /**
+     * Configuration for table header data which controls sorting, filtering, and additional metadata.
+     */
     headerData: TableHeaderCell[];
+    /**
+     * FormGroup to handle the dynamic filtering controls, each tied to a header cell that has filtering enabled.
+     */
     form: FormGroup;
+    /**
+     * Event emitter for when a column's sorting status changes.
+     */
     readonly sorted: EventEmitter<SortStatus>;
+    /**
+     * Event emitter for when the table's filtering conditions change.
+     */
     readonly filtered: EventEmitter<{
         [key: string]: string;
     }>;
+    /**
+     * Event emitter for when a checkbox column's checked state changes.
+     */
     readonly checked: EventEmitter<{
         column: string;
         check: boolean;
     }>;
+    /**
+     * A QueryList of HeaderTitleComponent instances, each corresponding to a header cell in the table.
+     */
     headers: QueryList<HeaderTitleComponent>;
     ngOnInit(): void;
+    /**
+     * Clears the sorting status of all headers.
+     */
     clearSort(): void;
     private formListener;
     private setHeaderData;

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

@@ -11,7 +11,7 @@ import * as i0 from "@angular/core";
  * Represents a time picker component allowing users to select a time from a dropdown list.
  * This component integrates with Angular forms and supports customization for locale, time range, and step intervals.
  *
- * @extends {CustomFormControl<string | null>}
+ * @see {CustomFormControl}
  */
 export declare class TimepickerComponent extends CustomFormControl<string | null> implements AfterViewInit {
     private readonly timepickerService;
@@ -27,6 +27,10 @@ export declare class TimepickerComponent extends CustomFormControl<string | null
      * @default false
      */
     set useLocale(val: boolean);
+    /**
+     * Gets a boolean value indicating whether the locale is being used.
+     * @returns {boolean} A boolean value indicating whether the locale is being used.
+     */
     get useLocale(): boolean;
     /**
      * Controls the step interval between time options in minutes.
@@ -46,7 +50,11 @@ export declare class TimepickerComponent extends CustomFormControl<string | null
     dateField?: TimepickerInputControlDirective;
     constructor();
     ngAfterViewInit(): void;
-    onOpen(): void;
+    /**
+     * Checks if the given time option is selected.
+     * @param option - The time option to check.
+     * @returns True if the option is selected, false otherwise.
+     */
     isTimeOptionSelected(option: TimepickerOptionComponent): boolean;
     /**
      * Handles the selection of a time option from the dropdown, updating the input field and closing the dropdown.
@@ -67,6 +75,7 @@ export declare class TimepickerComponent extends CustomFormControl<string | null
      * @returns {string[]} An array of time strings in 'HH:mm' format.
      */
     get timeStampsList(): string[];
+    protected onOpen(): void;
     protected handleControllerEvent(event: KeyboardEvent): void;
     protected handleDateFieldChanges(): void;
     private setActiveOptionBasedOnCurrentValue;

package/components/timepicker/lib/utils/generate-time-stamps.d.ts

@@ -6,13 +6,14 @@
  * @param {boolean} useLocale - Determines if the time stamps should use the 12-hour format with AM/PM (`true`) or the 24-hour format (`false`).
  * @returns {string[]} An array of formatted time stamps as strings.
  * @example
+ * ```ts
  * // Generate time stamps every 30 minutes using 24-hour format
  * generateTimeStamps(30, false);
  * // Returns ["00:00", "00:30", "01:00", ..., "23:30"]
  *
- * @example
  * // Generate time stamps every 60 minutes using 12-hour format with AM/PM
  * generateTimeStamps(60, true);
  * // Returns ["12:00 AM", "01:00 AM", ..., "11:00 PM"]
+ * ```
  */
 export declare function generateTimeStamps(step: number, useLocale: boolean): string[];

package/components/timepicker/lib/utils/ngx-mask-helper.d.ts

@@ -8,15 +8,15 @@
  * @returns {string} The processed and potentially reformatted value.
  *
  * @example
+ * ```ts
  * // Prepend 0 to single-digit hours greater than 1
  * processInputValue("2", { inputType: "insertText" }); // Returns "02"
  *
- * @example
  * // Ensure minute values are within valid ranges
  * processInputValue("11:8", { inputType: "insertText" }); // Returns "11:08"
  *
- * @example
  * // Append 'M' to AM/PM indicators
  * processInputValue("2 p", { inputType: "insertText" }); // Returns "2 PM"
+ * ```
  */
 export declare function processInputValue(value: string, event: InputEvent): string;

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

@@ -1,5 +1,5 @@
-import { EventEmitter, OnInit } from '@angular/core';
-import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
+import { EventEmitter, OnInit, Type } from '@angular/core';
+import { DynamicContent, DynamicTextContent, GetDynamicViewContext } from '@odx/angular/cdk/dynamic-view';
 import { ToastAction, ToastOptions, ToastVariant } from '../../models';
 import * as i0 from "@angular/core";
 export declare class ToastItemComponent implements OnInit {
@@ -8,7 +8,8 @@ export declare class ToastItemComponent implements OnInit {
     get icon(): string;
     id: string;
     title: DynamicTextContent;
-    description?: DynamicTextContent | null;
+    description?: DynamicContent | null;
+    descriptionContext?: GetDynamicViewContext<Type<unknown>>;
     variant?: ToastVariant | null;
     actions?: ToastAction[];
     options: ToastOptions;
@@ -16,5 +17,5 @@ export declare class ToastItemComponent implements OnInit {
     ngOnInit(): void;
     onDismiss(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToastItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ToastItemComponent, "odx-toast", never, { "id": { "alias": "id"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastItemComponent, "odx-toast", never, { "id": { "alias": "id"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "descriptionContext": { "alias": "descriptionContext"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
 }

package/components/toast/lib/models/toast.d.ts

@@ -1,10 +1,12 @@
-import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
+import { Type } from '@angular/core';
+import { DynamicContent, DynamicTextContent, GetDynamicViewContext } from '@odx/angular/cdk/dynamic-view';
 import { ToastAction } from './toast-action';
 import { ToastVariant } from './toast-variant';
 export interface Toast {
     id?: string;
     title: DynamicTextContent;
-    description?: DynamicTextContent;
+    description?: DynamicContent;
+    descriptionContext?: GetDynamicViewContext<Type<unknown>>;
     actions?: ToastAction[];
     variant?: ToastVariant;
 }

package/components/toast/lib/toast.config.d.ts

@@ -1,3 +1,29 @@
 import { ToastOptions } from './models/toast.options';
 export type ToastConfig = ToastOptions;
+/**
+ * Utility functions generated by `createConfigTokens` to handle injection and provision of `ToastConfig`.
+ * These include tokens and functions to access and provide the default configuration for toasts.
+ *
+ * `ToastDefaultConfig` provides the default settings for toasts.
+ * `ToastConfig` is a token that can be used to inject toast configuration settings.
+ * `injectToastConfig` is a function that retrieves the current toast configuration.
+ * `provideToastConfig` is a function used to specify a custom configuration for toasts.
+ *
+ * @example
+ * ```ts
+ * // In module providers:
+ * providers: [
+ *  provideToastConfig({ // ... global module configuration }),
+ * ]
+ *
+ * // In a component or service:
+ * constructor(@Inject(ToastConfig) private readonly config: ToastConfig) {}
+ *
+ * // Or using the `injectToastConfig` function:
+ * @Component({ ... })
+ * export class MyComponent {
+ *  private readonly config = injectToastConfig();
+ * }
+ * ```
+ */
 export declare const ToastDefaultConfig: ToastOptions, ToastConfig: import("@angular/core").InjectionToken<Partial<ToastOptions>>, injectToastConfig: () => ToastOptions, provideToastConfig: <D extends import("@odx/angular/utils").ConfigDependencies<unknown> = import("@odx/angular/utils").ConfigDependencies<Partial<ToastOptions>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<ToastOptions>, D>) => import("@angular/core").FactoryProvider | import("@angular/core").ValueProvider;

package/components/toast/lib/toast.service.d.ts

@@ -1,14 +1,34 @@
 import { Toast, ToastOptions, ToastRef } from './models';
 import * as i0 from "@angular/core";
+/**
+ * ToastService provides a centralized management system for toasts within an application.
+ * It handles the creation, updates, and dismissal of toasts based on a FIFO (first-in, first-out) queue.
+ * This service integrates custom toast options with default configurations and supports reactive updates through observables.
+ */
 export declare class ToastService {
     private readonly queue;
     private readonly defaultOptions;
+    /**
+     * Observable stream of active toasts.
+     */
     readonly toasts$: import("rxjs").Observable<(ToastRef & {
         id: string | number;
     })[]>;
+    /**
+     * Observable that emits when any update occurs in the toast queue.
+     */
     readonly onUpdate$: import("rxjs").Observable<ToastRef>;
+    /**
+     * Observable that emits when a toast is added.
+     */
     readonly onToastAdd$: import("rxjs").Observable<ToastRef>;
+    /**
+     * Observable that emits when a toast is updated.
+     */
     readonly onToastUpdate$: import("rxjs").Observable<ToastRef>;
+    /**
+     * Observable that emits when a toast is removed.
+     */
     readonly onToastRemove$: import("rxjs").Observable<ToastRef>;
     /**
      * @deprecated Use `toasts$` instead
@@ -28,16 +48,31 @@ export declare class ToastService {
      * @deprecated Use `create` instead
      */
     add(item: Toast, options?: Partial<ToastOptions>): ToastRef;
+    /**
+     * Creates and queues a new toast based on the provided item and options.
+     * Merges given options with default configurations.
+     * @param {Toast} item The toast item to create.
+     * @param {Partial<ToastOptions>} options Optional additional options for the toast.
+     * @returns {ToastRef} The reference to the newly created toast.
+     */
     create(item: Toast, options?: Partial<ToastOptions>): ToastRef;
     /**
      * @deprecated Use `dismiss` instead
      */
     remove(refOrId: ToastRef | ToastRef['id']): ToastRef | null;
+    /**
+     * Dismisses a specific toast identified by a reference or ID.
+     * @param {ToastRef | ToastRef['id']} refOrId The reference or ID of the toast to dismiss.
+     * @returns {ToastRef | null} The reference to the dismissed toast, or null if not found.
+     */
     dismiss(refOrId: ToastRef | ToastRef['id']): ToastRef | null;
     /**
      * @deprecated Use `dismissAll` instead
      */
     clear(): void;
+    /**
+     * Dismisses all toasts currently being displayed.
+     */
     dismissAll(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;

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

@@ -1,9 +1,20 @@
 import { ElementRef } from '@angular/core';
 import { RadioControlDirective } from '@odx/angular/cdk/radio-group-control';
 import * as i0 from "@angular/core";
+/**
+ * ToggleButtonComponent represents an individual toggle button, akin to a radio button but styled distinctly.
+ * It integrates with Angular's forms as part of a radio group control, allowing for keyboard navigation and
+ * accessibility features. This component is designed to be used within a `ToggleButtonGroupComponent`.
+ * Extends RadioControlDirective to provide additional behavior.
+ *
+ * @see {RadioControlDirective}
+ */
 export declare class ToggleButtonComponent<T = unknown> extends RadioControlDirective<T> {
     protected inputElement: ElementRef<HTMLInputElement>;
     readonly element: ElementRef<HTMLElement>;
+    /**
+     * Sets focus to the input element of the toggle button.
+     */
     focus(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonComponent<any>, "odx-toggle-button", never, {}, {}, never, ["*"], true, never>;

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

@@ -3,6 +3,18 @@ import { RadioGroupControlDirective } from '@odx/angular/cdk/radio-group-control
 import { ToggleButtonComponent } from './components';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * ToggleButtonGroupComponent acts as a container for a group of toggle buttons,
+ * managing their state and focus within a group context.
+ *
+ * It extends the RadioGroupControlDirective, allowing it to control the selection and state
+ * of contained toggle buttons similar to how radio buttons are managed.
+ *
+ * Has host directive DelegateFocusDirective.
+ *
+ * @see {RadioGroupControlDirective}
+ * @see {DelegateFocusDirective}
+ */
 export declare class ToggleButtonGroupComponent<T = unknown> extends RadioGroupControlDirective<T> implements OnInit {
     private readonly delegateFocusDirective;
     private readonly takeUntilDestroyed;

package/components/tooltip/lib/helpers/resolve-tooltip-trigger-events.d.ts

@@ -1,2 +1,9 @@
 import { TooltipTrigger } from '../models';
+/**
+ * @internal
+ * Resolves the appropriate event names for the provided tooltip trigger.
+ *
+ * @param {TooltipTrigger} trigger - The trigger to resolve.
+ * @returns {[string, string | null]} - The event names for the trigger.
+ */
 export declare function resolveTooltipTriggerEvents(trigger: TooltipTrigger): [string, string | null];

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

@@ -2,11 +2,31 @@ import { Injector, Type } from '@angular/core';
 import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
 import { TooltipSize } from './models';
 import * as i0 from "@angular/core";
+/**
+ /**
+ * TooltipComponent displays contextual information related to an element when the user hovers over
+ * or focuses on the element. It supports dynamic content and can be styled with different sizes.
+ *
+ * The component uses dynamic content rendering to provide flexible display options including text,
+ * templates, or even other Angular components, making it highly customizable.
+ */
 export declare class TooltipComponent {
     protected readonly injector: Injector;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The ID attribute of the tooltip, used for accessibility purposes to link the tooltip with its owner element.
+     */
     id: string | null;
+    /**
+     * The content to be displayed within the tooltip. This can be text, a template reference, or a dynamic component.
+     */
     content?: Exclude<DynamicContent, Type<unknown>> | null;
+    /**
+     * Determines the size of the tooltip. It can adjust based on the content size or be set to specific dimensions.
+     * The size influences the CSS class applied to the tooltip, allowing for custom styles.
+     *
+     * @see {TooltipSize}
+     */
     size: TooltipSize;
     static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "odx-tooltip", never, { "id": { "alias": "id"; "required": false; }; "content": { "alias": "content"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;

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

@@ -3,6 +3,11 @@ import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
 import { NgChanges } from '@odx/angular/utils';
 import { TooltipOptions, TooltipSize } from './models';
 import * as i0 from "@angular/core";
+/**
+ * TooltipDirective manages tooltips for host elements by creating overlay components dynamically.
+ * It provides configuration options such as content, delay timings, visibility, and tooltip sizing.
+ * This directive uses Angular's connected overlay system to position and manage tooltip visibility.
+ */
 export declare class TooltipDirective implements OnInit, OnChanges {
     private readonly eventManager;
     private readonly connectedOverlayService;
@@ -12,16 +17,46 @@ export declare class TooltipDirective implements OnInit, OnChanges {
     private tooltipOptions;
     protected tooltipId: string | null;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Input for dynamic content to display in the tooltip.
+     * This content is reactive and can change dynamically.
+     */
     content?: Exclude<DynamicContent, Type<unknown>> | null;
+    /**
+     * Controls whether the tooltip is disabled. A disabled tooltip will not be displayed.
+     */
     disabled: boolean;
+    /**
+     * Configuration options for the tooltip.
+     * It allows setting various behaviors like delay and positioning.
+     *
+     * @see {TooltipOptions}
+     */
     set options(value: Partial<TooltipOptions> | null | undefined);
+    /**
+     * Sets the size of the tooltip.
+     * @see {TooltipSize}
+     */
     size?: TooltipSize | null;
+    /**
+     * Controls the visibility of the tooltip.
+     * Useful for programmatically toggling the tooltip display.
+     */
     visible: boolean;
+    /**
+     * Indicates whether the tooltip is currently open.
+     */
     get isOpen(): boolean;
     constructor();
     ngOnInit(): void;
     ngOnChanges(changes: NgChanges<TooltipDirective>): void;
+    /**
+     * Shows the tooltip, creating and attaching the overlay to the host element.
+     */
     show(): void;
+    /**
+     * Hides the tooltip, detaching the overlay from the host element.
+     */
     hide(): void;
     private registerEvents;
     static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;

package/components/wizard/lib/components/wizard-step/wizard-step.component.d.ts

@@ -1,15 +1,49 @@
 import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * WizardStepComponent represents an individual step within a wizard navigation sequence. It can be configured
+ * to display icons, listen for user interactions, and indicate various states such as active, passed, or valid.
+ * This component interacts with the WizardComponent to manage the step progression and visibility.
+ *
+ * Has host directives WithTabIndex and WithDisabledState.
+ *
+ * @see {WithTabIndex}
+ * @see {WithDisabledState}
+ */
 export declare class WizardStepComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Emitted when the step is chosen by the user, indicating that the step should be activated.
+     */
     readonly stepChosen$: Subject<WizardStepComponent>;
+    /**
+     * Indicates if this step was the last one interacted with in the wizard sequence.
+     */
     isLastTouched: boolean;
+    /**
+     * Indicates if this step is currently active.
+     */
     active: boolean;
+    /**
+     * Indicates if this step has been passed in the navigation sequence.
+     */
     passed: boolean;
+    /**
+     * Controls the visibility of this step in the UI.
+     */
     visible: boolean;
+    /**
+     * Indicates if this step is valid and can be progressed to.
+     */
     valid: boolean;
+    /**
+     * Indicates if this step has been touched by the user.
+     */
     touched: boolean;
+    /**
+     * Sets the validation state of this step.
+     */
     setValid(state: boolean): void;
     protected chooseStep(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WizardStepComponent, never>;

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

@@ -1,6 +1,11 @@
 import { AfterViewInit, EventEmitter, QueryList } from '@angular/core';
 import { WizardStepComponent } from './components';
 import * as i0 from "@angular/core";
+/**
+ * WizardComponent manages a series of steps, providing functionality for navigating forwards and backwards
+ * through the steps. It dynamically adjusts the visibility of steps based on the available space and current active step.
+ * The component supports both horizontal and vertical orientations.
+ */
 export declare class WizardComponent implements AfterViewInit {
     private readonly destroyed;
     private readonly renderer;
@@ -11,11 +16,26 @@ export declare class WizardComponent implements AfterViewInit {
     private activeStep;
     protected readonly steps: QueryList<WizardStepComponent>;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates if the wizard layout should be vertical. When true, the wizard orientation changes to vertical.
+     */
     vertical: boolean;
+    /**
+     * Event emitted when the active step changes, providing the index of the new active step.
+     */
     activeStepChanged: EventEmitter<number>;
     ngAfterViewInit(): void;
+    /**
+     * Navigates to the next step in the wizard.
+     */
     nextStep(): void;
+    /**
+     * Navigates to the previous step in the wizard.
+     */
     previousStep(): void;
+    /**
+     * Sets the active step to the specified index.
+     */
     setActiveStepValid(): void;
     private calculateVisibleStepsSegments;
     private getStyleFromCSS;