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;
    /**
     * DOM-order index of the step this trigger belongs to (from the item
     * context), used to map a trigger position back to its step index for
     * selection.
     */
    readonly index: Signal<number>;
    /** 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 the roving
     * tracker's reconciliation, which read a `disabled` signal per handle.
     */
    readonly disabled: Signal<boolean>;
}
/**
 * Registry entry for one content panel (id source). The panel's step index is
 * carried on the handle, so a lookup never conflates it with the panel's
 * position in the content collection.
 */
interface ForStepperContentHandle {
    /** Host element, used for DOM-order sorting and index derivation. */
    readonly host: HTMLElement;
    /**
     * Index of the step this panel is paired with — the explicit `[step]` when
     * bound, else the panel's DOM-order position among the registered panels.
     */
    readonly index: Signal<number>;
    /** 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). Arrow navigation lands on disabled / linear-unreachable triggers
     * too (they stay focusable per the APG); automatic-mode selection is guarded
     * so it never activates a non-selectable step. Selection resolves the target
     * step by its item index (carried on the trigger handle), not by the trigger's
     * position in the trigger collection.
     */
    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 belonging to step `index`, or `null` when no
     * registered trigger claims that step. Resolved through the trigger handle's
     * item index, so a structurally hidden trigger never shifts the pairing.
     */
    triggerIdFor(index: number): string | null;
    /**
     * Returns the id of the content panel paired with step `index`, or `null`
     * when no registered panel claims that step. Resolved through the content
     * handle's step index, so a structurally absent panel never shifts the
     * pairing.
     */
    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` as the positional
     * fallback when the panel declares no explicit `[step]`.
     */
    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. Matched on
     * the trigger handle's item index, never on its collection position.
     */
    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>;
    protected readonly resolvedAriaLabel: _angular_core.Signal<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.
 *
 * In `mode="interactive"` the host carries `role="presentation"` so the
 * `ForStepperList` `role="tablist"` owns the `role="tab"` triggers directly — an
 * interposed implicit `listitem` would violate the tablist's required-owned-
 * elements contract. In `mode="progress"` the implicit `listitem` is kept (it
 * sits correctly under the list's `role="list"`).
 */
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 reflect `aria-disabled` + `data-disabled`
 * (never the native `disabled` attribute) and drop out of the Tab sequence
 * (`tabindex` `-1`), but REMAIN reachable by arrow navigation: focus lands on
 * them and activation is a no-op, so assistive tech announces them in both
 * browse and focus / interaction modes.
 */
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:
     * - `-1` 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. Pairs with a step through the explicit `[step]` index
 * when bound; otherwise by **position** — the Nth `[forStepperContent]` panel in
 * registration (DOM document) order corresponds to the Nth step. Bind `[step]`
 * whenever panels are conditionally rendered or ordered independently of the
 * steps, since the positional fallback renumbers the remaining panels.
 *
 * 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;
    /**
     * Index of the step this panel belongs to. Leave unset (default `null`) to
     * pair by DOM-order position among the registered panels; bind it when panels
     * are conditionally rendered or ordered independently of the steps, so the
     * pairing survives a structurally absent panel.
     */
    readonly step: _angular_core.InputSignal<number | null>;
    /** Generated (or consumer-set static) id for this panel. Used by triggers for `aria-controls`. */
    readonly id: _angular_core.Signal<string>;
    /** Resolved step index — the explicit `step()` when bound, else the positional fallback. */
    readonly index: _angular_core.Signal<number>;
    /** True when this panel corresponds to the currently selected step. */
    readonly current: _angular_core.Signal<boolean>;
    /**
     * Resolved `aria-labelledby`: a consumer-set static value when present, else
     * the id of the trigger that labels this panel.
     */
    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"], { "step": { "alias": "step"; "required": false; "isSignal": true; }; }, {}, 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 directive forces `type="button"` through a host binding, so a consumer
 * `type="submit"` on the host cannot make advancing a step submit a surrounding
 * `<form>`.
 *
 * Clicking while `aria-disabled` is a no-op.
 */
declare class ForStepperNext {
    protected readonly buttonType: _angular_core.Signal<string | null>;
    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 directive forces `type="button"` through a host binding, so a consumer
 * `type="submit"` on the host cannot make going back a step submit a
 * surrounding `<form>`.
 *
 * Clicking while `aria-disabled` is a no-op.
 */
declare class ForStepperPrevious {
    protected readonly buttonType: _angular_core.Signal<string | null>;
    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`.
     * In both cases the percent is `value / count`, so `aria-valuenow` reaches
     * `100` only in the terminal completed state (`selectedIndex === count`) or,
     * on the `'completed'` basis, when every step is completed; standing on the
     * last step before completion reports less than `100`.
     */
    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>;
    protected readonly resolvedAriaLabel: _angular_core.Signal<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. Computed as `value / count`, so it reaches `100` only in
     * the terminal completed state (`selectedIndex === count`) or, on the
     * `'completed'` basis, when every step is completed; the last non-terminal
     * step reports less than `100`.
     */
    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. Both
     * strings are built from the scope's `stepValueText` / `progressValueText`
     * defaults, localizable via `provideForStepperDefaults`.
     */
    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;
    /**
     * Builds the `aria-valuetext` for `[forStepperProgress]` on the `'index'`
     * basis (default `"Step N of M"`). Override to localize centrally. `current`
     * is the 1-based current step and `total` is the step count.
     */
    stepValueText: (current: number, total: number) => string;
    /**
     * Builds the `aria-valuetext` for `[forStepperProgress]` on the `'completed'`
     * basis (default `"P% complete"`). Override to localize centrally. `percent`
     * is the whole-number completion percent in `[0, 100]`.
     */
    progressValueText: (percent: number) => string;
}
/** 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 };