forty-cdk 0.2.0 → 0.3.0

package/types/forty-cdk-stepper.d.ts

@@ -0,0 +1,650 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { WritingDirection, RovingTabindex, ListNavigationAction } from 'forty-cdk/core';
+import * as forty_cdk_stepper from 'forty-cdk/stepper';
+import { FieldTree } from '@angular/forms/signals';
+
+/** Activation timing for interactive-mode arrow navigation. */
+type StepperActivationMode = 'automatic' | 'manual';
+/** Accessibility model: interactive Tabs pattern vs display-only progress list. */
+type StepperMode = 'interactive' | 'progress';
+/**
+ * Registry entry for one step, owned by `ForStepperItem`. Drives index
+ * derivation and linear gating.
+ */
+interface ForStepperItemHandle {
+    /** Host element, used for DOM-order sorting in the collection. */
+    readonly host: HTMLElement;
+    /** Whether this step has been marked as completed by the consumer. */
+    readonly completed: Signal<boolean>;
+    /** Whether this step can be skipped when the stepper is in linear mode. */
+    readonly optional: Signal<boolean>;
+    /** Whether this step is disabled (own `disabled` OR root `disabled`). */
+    readonly effectiveDisabled: Signal<boolean>;
+    /** Whether this step has an error condition. */
+    readonly hasError: Signal<boolean>;
+    /** The resolved `data-state` string for this step. */
+    readonly resolvedState: Signal<string>;
+}
+/**
+ * Registry entry for one trigger (roving participant and id source). Used by
+ * the root to wire roving tabindex, id lookups, and navigation.
+ */
+interface ForStepperTriggerHandle {
+    /** Host element, used for DOM-order sorting and focus moves. */
+    readonly host: HTMLElement;
+    /** The trigger's own host id, for `aria-labelledby` on content panels. */
+    readonly id: Signal<string>;
+    /**
+     * Whether this trigger can be focused and activated. `false` when the step
+     * is disabled or not yet reachable in linear mode.
+     */
+    readonly selectable: Signal<boolean>;
+    /**
+     * Inverse of `selectable`. Required by `firstEnabledHost` and
+     * `reconcileRovingActive`, which read a `disabled` signal per handle.
+     */
+    readonly disabled: Signal<boolean>;
+}
+/**
+ * Registry entry for one content panel (id source; positional). The content's
+ * position in this collection determines its associated step index.
+ */
+interface ForStepperContentHandle {
+    /** Host element, used for DOM-order sorting and index derivation. */
+    readonly host: HTMLElement;
+    /** The panel's own host id, for `aria-controls` on triggers. */
+    readonly id: Signal<string>;
+}
+/**
+ * Coordination contract owned by `ForStepper`. Triggers, items, and content
+ * panels register here; navigation and selection flow back through these
+ * methods.
+ *
+ * Implements the [WAI-ARIA Tabs pattern](https://www.w3.org/WAI/ARIA/apg/patterns/tabs/)
+ * in `mode="interactive"` and a `<ol>`-based progress list with
+ * `aria-current="step"` in `mode="progress"`.
+ */
+interface ForStepperContext {
+    /** Two-way bindable selected step index. */
+    readonly selectedIndex: Signal<number>;
+    /** When true, steps are only reachable after all preceding steps are completed or optional. */
+    readonly linear: Signal<boolean>;
+    /** Accessibility model — `'interactive'` (Tabs APG) or `'progress'` (progress list). */
+    readonly mode: Signal<StepperMode>;
+    /** Layout axis for the step list. */
+    readonly orientation: Signal<'horizontal' | 'vertical'>;
+    /** Arrow-key activation timing when in interactive mode. */
+    readonly activationMode: Signal<StepperActivationMode>;
+    /** Resolved writing direction (`'ltr'` or `'rtl'`). */
+    readonly dir: Signal<WritingDirection>;
+    /** Whether the entire stepper is disabled. */
+    readonly disabled: Signal<boolean>;
+    /** Total number of registered step items. */
+    readonly count: Signal<number>;
+    /**
+     * True when the stepper has reached the terminal completed state
+     * (`selectedIndex()` >= `count()`).
+     */
+    readonly isCompleted: Signal<boolean>;
+    /** Roving tabindex tracker for interactive-mode triggers. */
+    readonly roving: RovingTabindex;
+    /** Returns the DOM-order index of `item` in the item collection, or -1 if not found. */
+    indexOf(item: ForStepperItemHandle): number;
+    /** Returns true when `index` matches the currently selected step. */
+    isCurrent(index: number): boolean;
+    /**
+     * Returns true when step `index` can be navigated to in linear mode. Index 0
+     * is always reachable; subsequent steps require all preceding steps to be
+     * completed or optional.
+     */
+    isReachable(index: number): boolean;
+    /** Returns the resolved `data-state` string for step at `index`. */
+    resolvedStateFor(index: number): string;
+    /**
+     * Selects step `index`. No-op when the root is disabled, when `index` is
+     * out of range, or when the step is not reachable in linear mode.
+     */
+    select(index: number): void;
+    /**
+     * Advances to the next step, or into the terminal completed state when on
+     * the last step. No-op when the root is disabled, when already in the terminal state, or
+     * (in linear mode) when the current step is neither completed nor optional.
+     */
+    next(): void;
+    /**
+     * Retreats to the previous step. No-op when the root is disabled or the
+     * first step is already selected. Bypasses the linear reachability gate —
+     * going back always works.
+     */
+    previous(): void;
+    /**
+     * Returns true when the Next button can advance — including advancing the last
+     * step into the terminal completed state. False when disabled, already in the
+     * terminal state, or (in linear mode) the current step is not completed/optional.
+     */
+    canAdvance(): boolean;
+    /** Returns true when the Previous button can retreat. False when disabled or at the first step. */
+    canRetreat(): boolean;
+    /**
+     * Moves focus from `currentTrigger` according to `action` (interactive mode
+     * only). In automatic activation mode, also selects the target step.
+     * Disabled / unreachable triggers are skipped.
+     */
+    navigate(currentTrigger: HTMLElement, action: ListNavigationAction): void;
+    /** Registers a step item handle into the item collection. */
+    registerItem(h: ForStepperItemHandle): void;
+    /** Unregisters a step item handle from the item collection. */
+    unregisterItem(h: ForStepperItemHandle): void;
+    /** Registers a trigger handle into the trigger collection. */
+    registerTrigger(h: ForStepperTriggerHandle): void;
+    /** Unregisters a trigger handle from the trigger collection and the roving tracker. */
+    unregisterTrigger(h: ForStepperTriggerHandle): void;
+    /** Registers a content panel handle into the content collection. */
+    registerContent(h: ForStepperContentHandle): void;
+    /** Unregisters a content panel handle from the content collection. */
+    unregisterContent(h: ForStepperContentHandle): void;
+    /**
+     * Returns the id of the trigger at `index`, or `null` if there is no
+     * registered trigger at that position.
+     */
+    triggerIdFor(index: number): string | null;
+    /**
+     * Returns the id of the content panel at `index`, or `null` if there is no
+     * registered panel at that position.
+     */
+    contentIdFor(index: number): string | null;
+    /**
+     * Returns the DOM-order index of the content panel whose host is `host`, or
+     * -1 if not registered. Used by `ForStepperContent` to derive its step index
+     * reactively.
+     */
+    indexOfContent(host: HTMLElement): number;
+    /**
+     * True when `el` is the first selectable trigger (the roving entry-point
+     * fallback when no step is selected or the roving pointer is stale).
+     */
+    isFirstSelectableTrigger(el: HTMLElement): boolean;
+    /**
+     * True when some registered trigger corresponds to the currently selected
+     * step. Distinguishes "the current step owns the tab stop" from "the selected
+     * index points at a missing or unreachable trigger" so the per-trigger
+     * tabindex fallback can re-engage the first-selectable entry point.
+     */
+    hasCurrentTrigger(): boolean;
+}
+/**
+ * Per-step state contract. Provided by `ForStepperItem`; consumed by
+ * `ForStepperTrigger`, `ForStepperIndicator`, and `ForStepperSeparator`.
+ */
+interface ForStepperItemContext {
+    /** DOM-order index of this step within the stepper. */
+    readonly index: Signal<number>;
+    /** True when this step is the currently selected step. */
+    readonly current: Signal<boolean>;
+    /**
+     * True when this step can be focused and activated (reachable and not
+     * effectively disabled).
+     */
+    readonly selectable: Signal<boolean>;
+    /** Whether this step has been marked as completed. */
+    readonly completed: Signal<boolean>;
+    /** Whether this step can be skipped when the stepper is in linear mode. */
+    readonly optional: Signal<boolean>;
+    /** Whether this step is disabled (own `disabled` OR root `disabled`). */
+    readonly effectiveDisabled: Signal<boolean>;
+    /** Whether this step has an error condition. */
+    readonly hasError: Signal<boolean>;
+    /** Resolved `data-state` string (precedence: custom state > error > active > completed > pending). */
+    readonly resolvedState: Signal<string>;
+    /**
+     * Selects this step. Delegates to `ForStepperContext.select(index)` — the
+     * linear reachability and disabled guards apply.
+     */
+    select(): void;
+}
+/** Injection token for the root stepper context (`ForStepper`). */
+declare const FOR_STEPPER_CONTEXT: InjectionToken<ForStepperContext>;
+/** Injection token for the per-step item context (`ForStepperItem`). */
+declare const FOR_STEPPER_ITEM_CONTEXT: InjectionToken<ForStepperItemContext>;
+
+/**
+ * Root of the Stepper primitive. Owns the selected step index, linear
+ * progression, accessibility mode, orientation, and disabled state. Provides
+ * the shared context to descendant directives.
+ *
+ * Implements the [WAI-ARIA Tabs pattern](https://www.w3.org/WAI/ARIA/apg/patterns/tabs/)
+ * in `mode="interactive"` (roving tabindex, `role="tablist"`, `aria-selected`)
+ * and an ordered-list progress pattern with `aria-current="step"` in
+ * `mode="progress"`.
+ *
+ * `activationMode='manual'` (default): arrow navigation only moves focus;
+ * Space / Enter activates. Recommended for wizards where step activation
+ * triggers validation. `activationMode='automatic'`: arrow navigation moves
+ * focus AND selects the step.
+ */
+declare class ForStepper implements ForStepperContext {
+    #private;
+    /**
+     * Two-way bindable selected step index in the inclusive range `0 … count`.
+     * Defaults to `0`. The terminal value `=== count()` (one past the last step) is
+     * the **completed** state (see `isCompleted` / `complete`). The `model()` change
+     * emitter (`(selectedIndexChange)`) fires only on internal selection changes
+     * (trigger click, Next/Previous, automatic-mode arrow navigation), never on
+     * consumer writes via `[(selectedIndex)]`.
+     */
+    readonly selectedIndex: _angular_core.ModelSignal<number>;
+    /**
+     * Emits once each time the stepper transitions **into** the completed terminal
+     * state — i.e. when `selectedIndex()` reaches `count()`. Does not re-emit while
+     * it stays completed; retreating via `previous()` and re-entering emits again.
+     */
+    readonly complete: _angular_core.OutputEmitterRef<void>;
+    /**
+     * When true, steps are only reachable after all preceding steps are completed
+     * or optional. Navigating back (`previous()`) always works regardless of this
+     * flag.
+     */
+    readonly linear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Accessibility model. `'interactive'` (default): full WAI-ARIA Tabs pattern
+     * — `role="tablist"`, `role="tab"`, `role="tabpanel"`, roving tabindex, arrow
+     * navigation. `'progress'`: ordered list with `aria-current="step"` on the
+     * active trigger — no tab stop manipulation.
+     */
+    readonly mode: _angular_core.InputSignal<StepperMode>;
+    /**
+     * Layout axis for the step list. Affects `aria-orientation` on the list and
+     * which arrow keys navigate in interactive mode.
+     */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * Arrow-key activation timing in interactive mode. Defaults to the value from
+     * `provideForStepperDefaults` for the surrounding scope (library default:
+     * `'manual'`).
+     */
+    readonly activationMode: _angular_core.InputSignal<StepperActivationMode>;
+    /**
+     * Whether arrow navigation wraps around past the first / last selectable
+     * trigger. Defaults to the value from `provideForStepperDefaults` for the
+     * surrounding scope (library default: `true`).
+     */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When true, all step triggers are non-interactive and the root carries
+     * `data-disabled`.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Writing direction. When unset (default `null`), the inherited ambient
+     * direction is resolved from the nearest ancestor carrying a `dir` attribute
+     * (or `<html dir>`), defaulting to `'ltr'`. An explicit `[dir]` always wins.
+     * The resolved value is reflected to the host `dir` attribute and swaps
+     * ArrowLeft / ArrowRight semantics in RTL.
+     */
+    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
+    readonly dir: _angular_core.Signal<WritingDirection>;
+    readonly roving: RovingTabindex;
+    /** Total number of registered step items. */
+    readonly count: _angular_core.Signal<number>;
+    /**
+     * True when the stepper is in the terminal **completed** state: `selectedIndex()`
+     * has reached `count()` (one past the last step). No step is current and every
+     * `[forStepperContent]` panel is inactive while this holds.
+     */
+    readonly isCompleted: _angular_core.Signal<boolean>;
+    constructor();
+    indexOf(item: ForStepperItemHandle): number;
+    isCurrent(index: number): boolean;
+    isReachable(index: number): boolean;
+    resolvedStateFor(index: number): string;
+    select(index: number): void;
+    next(): void;
+    previous(): void;
+    canAdvance(): boolean;
+    canRetreat(): boolean;
+    navigate(currentTrigger: HTMLElement, action: ListNavigationAction): void;
+    registerItem(h: ForStepperItemHandle): void;
+    unregisterItem(h: ForStepperItemHandle): void;
+    registerTrigger(h: ForStepperTriggerHandle): void;
+    unregisterTrigger(h: ForStepperTriggerHandle): void;
+    registerContent(h: ForStepperContentHandle): void;
+    unregisterContent(h: ForStepperContentHandle): void;
+    triggerIdFor(index: number): string | null;
+    contentIdFor(index: number): string | null;
+    indexOfContent(host: HTMLElement): number;
+    isFirstSelectableTrigger(el: HTMLElement): boolean;
+    hasCurrentTrigger(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepper, "[forStepper]", ["forStepper"], { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "complete": "complete"; }, never, never, true, never>;
+}
+
+/**
+ * The step-list container. In `mode="interactive"` renders as `role="tablist"`
+ * with `aria-orientation`; in `mode="progress"` renders as `role="list"`.
+ *
+ * Apply on an `<ol>` (recommended for semantic list markup) wrapping the
+ * `[forStepperItem]` elements. The `[forStepperContent]` panels live as
+ * siblings of the list.
+ */
+declare class ForStepperList {
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    /** Accessible name for the step list. Defers to a consumer `aria-labelledby`. */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperList, "[forStepperList]", ["forStepperList"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * One step within a `ForStepper`. Owns per-step state (`completed`, `optional`,
+ * `disabled`, `hasError`, `state`) and exposes the `ForStepperItemContext` that
+ * child `[forStepperTrigger]`, `[forStepperIndicator]`, and
+ * `[forStepperSeparator]` directives consume.
+ *
+ * Apply on a list item element (e.g. `<li forStepperItem>`). The step's index
+ * is derived reactively from its DOM position within the stepper via the root's
+ * item collection.
+ */
+declare class ForStepperItem implements ForStepperItemContext, ForStepperItemHandle {
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    /** Host element — satisfies `ForStepperItemHandle.host` for collection registration. */
+    readonly host: HTMLElement;
+    /**
+     * Manual completion flag. When `true`, the step is completed regardless of any
+     * bound `field()`. Bind via `[completed]`.
+     */
+    readonly _completedInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marks this step as optional (can be skipped in linear mode). */
+    readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When true, this step's trigger ignores clicks and the step is unreachable by keyboard. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Manual error flag. When `true`, the step reflects the `'error'` resolved state
+     * (unless current) regardless of any bound `field()`. Bind via `[hasError]`.
+     */
+    readonly _hasErrorInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Optional Signal Forms field. When bound, the step's `completed` and
+     * `hasError` derive from the field's reactive validity: `completed` is `true`
+     * when the field is valid and touched; `hasError` is `true` when the field is
+     * touched and invalid. A manual `[completed]` / `[hasError]` input always wins
+     * when set. Leave unset to drive completion manually.
+     *
+     * The `@angular/forms` peer is optional: the field *type* is imported with
+     * `import type`, so binding `[field]` requires the peer but the primitive
+     * compiles and tree-shakes without it for consumers who never use it.
+     */
+    readonly field: _angular_core.InputSignal<FieldTree<unknown> | null>;
+    /**
+     * Whether this step is completed. A manual `[completed]` input wins; otherwise,
+     * when a `field()` is bound, derives `true` from `field` valid + touched.
+     */
+    readonly completed: _angular_core.Signal<boolean>;
+    /**
+     * Whether this step has an error. A manual `[hasError]` input wins; otherwise,
+     * when a `field()` is bound, derives `true` from `field` touched + invalid.
+     */
+    readonly hasError: _angular_core.Signal<boolean>;
+    /**
+     * Custom state string override. When non-empty, wins over the derived resolved
+     * state (`error`, `active`, `completed`, `pending`) and drives every
+     * `data-state` attribute on this step.
+     */
+    readonly state: _angular_core.InputSignal<string | null>;
+    /** Whether this step is disabled — own `disabled` OR the root stepper's `disabled`. */
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /** DOM-order index of this step within the stepper. */
+    readonly index: _angular_core.Signal<number>;
+    /** True when this step is the currently selected step. */
+    readonly current: _angular_core.Signal<boolean>;
+    /**
+     * True when this step can be focused and activated. False when the step is
+     * effectively disabled or not yet reachable in linear mode.
+     */
+    readonly selectable: _angular_core.Signal<boolean>;
+    /**
+     * Resolved `data-state` string. Precedence:
+     * 1. Custom `state()` when non-empty.
+     * 2. `'error'` when `hasError()` and not current.
+     * 3. `'active'` when current.
+     * 4. `'completed'` when `completed()`.
+     * 5. `'pending'` otherwise.
+     */
+    readonly resolvedState: _angular_core.Signal<string>;
+    constructor();
+    /** Selects this step. Delegates to `ForStepperContext.select(index)`. */
+    select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperItem, "[forStepperItem]", ["forStepperItem"], { "_completedInput": { "alias": "completed"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "_hasErrorInput": { "alias": "hasError"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Header for one step. In `mode="interactive"` carries `role="tab"`, participates
+ * in the roving tabindex, and wires `aria-selected` / `aria-controls` /
+ * `aria-disabled`. In `mode="progress"` carries `aria-current="step"` on the
+ * active step only and is a static element (no tab-stop manipulation).
+ *
+ * Apply on a `<button type="button">` for interactive mode so Enter / Space
+ * activation is native. A static element (`<span>`) is acceptable for progress
+ * mode.
+ *
+ * Disabled triggers in interactive mode keep their tab stop (`aria-disabled`
+ * instead of native `disabled`) so assistive tech can announce them.
+ */
+declare class ForStepperTrigger {
+    #private;
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    protected readonly item: forty_cdk_stepper.ForStepperItemContext;
+    /** Generated (or consumer-set static) id for this trigger. Used by content panels for `aria-labelledby`. */
+    readonly id: _angular_core.Signal<string>;
+    /** Id of the content panel this trigger controls (the matching panel by step index). */
+    protected readonly controlsId: _angular_core.Signal<string | null>;
+    /**
+     * APG tabindex cascade (interactive mode only). In progress mode returns
+     * `null` so no tab-stop attribute is emitted. In interactive mode:
+     * - `null` when not selectable (disabled or unreachable in linear mode).
+     * - Roving-tracker value once any trigger has been focused.
+     * - `0` when this step is current.
+     * - `-1` when another trigger owns the current step.
+     * - `0` if this is the first selectable trigger (fallback entry point).
+     * - `-1` otherwise.
+     */
+    protected readonly tabindex: _angular_core.Signal<0 | -1 | null>;
+    constructor();
+    protected onClick(): void;
+    protected onFocus(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperTrigger, "[forStepperTrigger]", ["forStepperTrigger"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Decorative icon slot for a step. Hidden from the accessibility tree
+ * (`aria-hidden="true"`). Reflects the step's resolved `data-state` so
+ * consumers can swap icons via CSS `[data-state="completed"]`,
+ * `[data-state="error"]`, etc., or with `@if` keyed on the exported
+ * `#indicator="forStepperIndicator"` reference.
+ *
+ * Must be used inside a `[forStepperItem]` element.
+ */
+declare class ForStepperIndicator {
+    protected readonly item: forty_cdk_stepper.ForStepperItemContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperIndicator, "[forStepperIndicator]", ["forStepperIndicator"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Decorative connector between steps. Hidden from the accessibility tree
+ * (`aria-hidden="true"`). Reflects `data-state="completed"` when the preceding
+ * step is marked completed, `data-state="pending"` otherwise. Also reflects
+ * `data-orientation` so consumers can style horizontal vs vertical separators
+ * differently.
+ *
+ * Must be used inside a `[forStepperItem]` element.
+ */
+declare class ForStepperSeparator {
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    protected readonly item: forty_cdk_stepper.ForStepperItemContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperSeparator, "[forStepperSeparator]", ["forStepperSeparator"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Panel for one step. Correlates to a step by **position** — the Nth
+ * `[forStepperContent]` panel in registration (DOM document) order corresponds
+ * to the Nth step.
+ *
+ * In `mode="interactive"` the panel carries `role="tabpanel"` and is a tab
+ * stop (`tabindex="0"`) only when it has no focusable content of its own
+ * (WAI-ARIA Tabs APG rule). In `mode="progress"` the panel carries
+ * `role="group"` and is never a tab stop.
+ *
+ * While inactive the directive reflects `aria-hidden="true"` and `inert` so
+ * mounted-but-inactive panels are removed from the accessibility tree and focus
+ * order automatically. DOM presence is the consumer's responsibility — wrap
+ * with `@if (current())` to unmount or leave mounted and toggle visibility with
+ * CSS via `[data-state="inactive"]`.
+ */
+declare class ForStepperContent {
+    #private;
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    /** Generated (or consumer-set static) id for this panel. Used by triggers for `aria-controls`. */
+    readonly id: _angular_core.Signal<string>;
+    /** True when this panel corresponds to the currently selected step. */
+    readonly current: _angular_core.Signal<boolean>;
+    /** Id of the trigger that labels this panel (`aria-labelledby`). */
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    /**
+     * APG tabindex: `'0'` only when in interactive mode and the panel has no
+     * focusable content of its own, so screen-reader users can reach the panel
+     * itself. A panel containing buttons / links / form controls gets no
+     * `tabindex`, avoiding a redundant tab stop.
+     */
+    protected readonly tabindex: _angular_core.Signal<"0" | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperContent, "[forStepperContent]", ["forStepperContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Terminal "all steps complete" panel. Shown (active) only while the stepper is in
+ * the completed state (`selectedIndex` has reached `count`); gated the same way as
+ * `[forStepperContent]` — `aria-hidden` / `inert` / `data-state` flip with
+ * `isCompleted()`. The natural place for a wizard's final success panel.
+ *
+ * DOM presence is the consumer's responsibility — wrap with `@if` driven by the same
+ * completed condition, or leave it mounted and toggle visibility with CSS via
+ * `[data-state="active"]`.
+ */
+declare class ForStepperCompletedContent {
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperCompletedContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperCompletedContent, "[forStepperCompletedContent]", ["forStepperCompletedContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * "Next" button for the stepper. Apply on a `<button>` element. Reflects
+ * `aria-disabled="true"` when `canAdvance()` is false (last step reached, root
+ * disabled, or in linear mode the current step is not completed / optional).
+ *
+ * The button retains its native `type="button"` attribute via the `type` host
+ * binding to prevent accidental form submission.
+ *
+ * Clicking while `aria-disabled` is a no-op because `next()` guards internally.
+ */
+declare class ForStepperNext {
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperNext, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperNext, "button[forStepperNext]", ["forStepperNext"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * "Previous" button for the stepper. Apply on a `<button>` element. Reflects
+ * `aria-disabled="true"` when `canRetreat()` is false (first step reached or
+ * root disabled).
+ *
+ * The button retains its native `type="button"` attribute via the `type` host
+ * binding to prevent accidental form submission.
+ *
+ * Clicking while `aria-disabled` is a no-op because `previous()` guards
+ * internally.
+ */
+declare class ForStepperPrevious {
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperPrevious, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperPrevious, "button[forStepperPrevious]", ["forStepperPrevious"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Optional progress indicator for the Stepper. Reads the stepper context and
+ * reflects how far through the steps the user is as a WAI-ARIA
+ * [`progressbar`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Roles/progressbar_role):
+ * `aria-valuemin="0"`, `aria-valuemax="100"`, `aria-valuenow` = the computed
+ * percent, and an `aria-valuetext` describing the position. Publishes a
+ * `--for-stepper-progress` (0–1) custom property for styling; ships no visuals.
+ *
+ * Must be used inside a `[forStepper]` element.
+ */
+declare class ForStepperProgress {
+    #private;
+    protected readonly ctx: forty_cdk_stepper.ForStepperContext;
+    /**
+     * Basis for the reported percent. `'index'` (default) derives progress from
+     * the current step index; `'completed'`
+     * derives it from the count of steps whose resolved state is `completed`.
+     */
+    readonly valueBy: _angular_core.InputSignal<"completed" | "index">;
+    /**
+     * Accessible name for the progressbar. Defaults to `null`, emitting no
+     * `aria-label`; prefer a visible label referenced via `aria-labelledby` when
+     * one exists.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * Progress as a whole-number percent in `[0, 100]`, reflected to
+     * `aria-valuenow` and (divided by 100) to the `--for-stepper-progress`
+     * custom property.
+     */
+    readonly percent: _angular_core.Signal<number>;
+    /**
+     * Human-readable position string reflected to `aria-valuetext`: `"Step X of N"`
+     * on the `'index'` basis, `"P% complete"` on the `'completed'` basis.
+     */
+    readonly valueText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForStepperProgress, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForStepperProgress, "[forStepperProgress]", ["forStepperProgress"], { "valueBy": { "alias": "valueBy"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant steppers in the surrounding injector scope.
+ * Configure with `provideForStepperDefaults` either at the application root or
+ * in any component's `providers` array; partial overrides merge with the parent
+ * scope.
+ */
+interface ForStepperDefaults {
+    /**
+     * `'manual'` (default): arrow navigation only moves focus; the user must
+     * press Space / Enter to activate. Recommended for wizards where step
+     * activation often triggers validation. `'automatic'`: arrow navigation moves
+     * focus AND selects the step.
+     */
+    activationMode: StepperActivationMode;
+    /**
+     * Whether arrow navigation wraps around past the first / last selectable
+     * trigger.
+     */
+    loop: boolean;
+}
+/** Token holding the resolved stepper defaults for the current scope. */
+declare const FOR_STEPPER_DEFAULTS: _angular_core.InjectionToken<ForStepperDefaults>;
+/**
+ * Configures forty-cdk stepper defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library defaults
+ * at the root).
+ */
+declare function provideForStepperDefaults(defaults?: Partial<ForStepperDefaults>): Provider[];
+
+export { FOR_STEPPER_CONTEXT, FOR_STEPPER_DEFAULTS, FOR_STEPPER_ITEM_CONTEXT, ForStepper, ForStepperCompletedContent, ForStepperContent, ForStepperIndicator, ForStepperItem, ForStepperList, ForStepperNext, ForStepperPrevious, ForStepperProgress, ForStepperSeparator, ForStepperTrigger, provideForStepperDefaults };
+export type { ForStepperContentHandle, ForStepperContext, ForStepperDefaults, ForStepperItemContext, ForStepperItemHandle, ForStepperTriggerHandle, StepperActivationMode, StepperMode };