forty-cdk 0.2.0 → 0.3.0

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

@@ -0,0 +1,310 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, ModelSignal, Signal, Provider } from '@angular/core';
+import { FormCheckboxControl, FormValueControl } from '@angular/forms/signals';
+import { FormUiControlBase, WritingDirection, RovingTabindex, ListNavigationAction, CollectionHandle } from 'forty-cdk/core';
+import * as forty_cdk_toggle from 'forty-cdk/toggle';
+
+/**
+ * Headless implementation of the [WAI-ARIA Toggle Button pattern](https://www.w3.org/WAI/ARIA/apg/patterns/button/) —
+ * a single-purpose `<button>` whose pressed state is reflected via
+ * `aria-pressed`. Implements Angular's `FormCheckboxControl` from
+ * `@angular/forms/signals` so a single toggle auto-wires with `[formField]`
+ * (bold / italic, mute, favourite — the common `aria-pressed` form inputs).
+ *
+ * Apply on a native `<button>` so Enter / Space and disabled handling come
+ * from the platform. The directive toggles its state on click and reflects
+ * ARIA + `data-state` for styling.
+ *
+ * For a set of toggles with arrow-key navigation and single / multiple
+ * selection semantics, use `[forToggleGroup]` + `[forToggleGroupItem]`.
+ *
+ * @example
+ * ```html
+ * <button forToggle [(checked)]="bold">B</button>
+ *
+ * <!-- With Signal Forms: -->
+ * <button forToggle [formField]="prefs.bold">B</button>
+ * ```
+ */
+declare class ForToggle extends FormUiControlBase implements FormCheckboxControl {
+    /**
+     * Two-way bindable on/off state. Required by `FormCheckboxControl`, so the
+     * toggle auto-wires with `[formField]`; the host reflects it through
+     * `aria-pressed` and `data-state` (still a toggle button — only the value's
+     * name is `checked`). The `model()` change emitter (`(checkedChange)`) fires
+     * only on internal transitions (user click), never on consumer writes via
+     * `[(checked)]`.
+     */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToggle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForToggle, "[forToggle]", ["forToggle"], { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Per-item handle stored in the group's `Collection`. The directive
+ * registers itself on construction so the group can compute selection,
+ * roving tabindex, and arrow-key navigation in DOM order.
+ */
+interface ForToggleGroupItemHandle extends CollectionHandle {
+    readonly value: Signal<string>;
+    readonly disabled: Signal<boolean>;
+}
+/**
+ * Coordination contract owned by `ForToggleGroup`. Items read selection
+ * and navigation policy from here and call back through `toggle` and
+ * `navigate` to drive state changes.
+ */
+interface ForToggleGroupContext {
+    readonly value: ModelSignal<readonly string[]>;
+    readonly multiple: Signal<boolean>;
+    /**
+     * The group's effective disabled — its own `disabled` input OR'd with a
+     * surrounding disabled `[forFieldset]`. Each item ORs this into its own
+     * `effectiveDisabled`, so a disabled group (or fieldset) disables every item.
+     */
+    readonly effectiveDisabled: Signal<boolean>;
+    readonly orientation: Signal<'horizontal' | 'vertical'>;
+    readonly dir: Signal<WritingDirection>;
+    readonly loop: Signal<boolean>;
+    /**
+     * Roving-tabindex tracker. Items call `setActive` on `(focus)` and prefer
+     * `active()` in their tabindex computed so the tab stop follows the last
+     * focused item (APG re-entry), matching Tabs / Tree.
+     */
+    readonly roving: RovingTabindex;
+    isSelected(value: string): boolean;
+    toggle(value: string): void;
+    navigate(currentItem: HTMLElement, action: ListNavigationAction): void;
+    isFirstFocusableItem(el: HTMLElement): boolean;
+    registerItem(handle: ForToggleGroupItemHandle): void;
+    unregisterItem(handle: ForToggleGroupItemHandle): void;
+}
+declare const FOR_TOGGLE_GROUP_CONTEXT: InjectionToken<ForToggleGroupContext>;
+
+/**
+ * Headless group of toggle buttons: a `role="group"` container whose items
+ * each carry `aria-pressed`, modelled on the
+ * [WAI-ARIA Button pattern](https://www.w3.org/WAI/ARIA/apg/patterns/button/)
+ * (toggle-button variant). Owns the
+ * selected-values set, navigation policy, and the registry of
+ * `[forToggleGroupItem]` children. Implements
+ * `FormValueControl<readonly string[]>` from `@angular/forms/signals` for
+ * `[formField]` auto-wiring. (The Toolbar pattern applies only when a group is
+ * nested inside `[forToolbar]`; see the composition note on
+ * `ForToggleGroupItem`.)
+ *
+ * Two selection modes:
+ * - multiple (`multiple=true`): clicking an item flips its presence in
+ *   `value`. Matches a "formatting toolbar" (Bold, Italic, Underline).
+ * - single (`multiple=false`, default): clicking selects exclusively;
+ *   clicking an already-selected item de-selects it (you can land on `[]`).
+ *   Matches an "alignment toolbar" (Left, Center, Right) where users may
+ *   want to clear the choice.
+ *
+ * `value` is always `readonly string[]` so consumers can flip `multiple`
+ * without re-typing their state. In single mode the array carries 0 or
+ * 1 entries.
+ *
+ * Roving tabindex: only one item is in the Tab sequence at a time. With
+ * a non-empty selection, the first selected item; otherwise the first
+ * enabled item in DOM order. Arrow keys move focus (no
+ * selection-on-focus — toggles always require an explicit click).
+ *
+ * `ForToggle` (the standalone single-button toggle) is also a form
+ * control, but a `FormCheckboxControl` carrying a single boolean value.
+ * Use `ForToggleGroup` (in single or multiple mode) when you need a set
+ * of pressed values as the form value.
+ */
+declare class ForToggleGroup extends FormUiControlBase implements FormValueControl<readonly string[]>, ForToggleGroupContext {
+    #private;
+    /**
+     * Two-way bindable. The currently pressed values, in arbitrary order.
+     * In single mode the array holds 0 or 1 entries. The `model()` change
+     * emitter (`(valueChange)`) fires only on internal transitions (item
+     * click), never on consumer writes via `[(value)]`. Required by
+     * `FormValueControl<readonly string[]>`.
+     */
+    readonly value: _angular_core.ModelSignal<readonly string[]>;
+    /**
+     * When false (default), only one item can be pressed at a time. Clicking
+     * an already-pressed item clears the selection. When true, clicks toggle
+     * each item independently.
+     */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Layout direction for keyboard navigation. */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * Reading direction. RTL swaps ArrowLeft/ArrowRight. 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 and the resolved value is
+     * reflected to the host `dir` attribute.
+     */
+    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
+    readonly dir: _angular_core.Signal<WritingDirection>;
+    /**
+     * When true (default), arrow nav wraps at the ends. The default is read
+     * from `provideForToggleDefaults` for the surrounding scope.
+     */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Roving-tabindex tracker. Items promote themselves to active on `(focus)`
+     * and read `active()` in their tabindex computed, so re-entry (Shift+Tab
+     * back into the group) restores the last focused item — matching Tabs /
+     * Tree. Before any focus, `active()` is `null` and the tabindex falls back
+     * to the first-selected / first-enabled entry point.
+     */
+    readonly roving: RovingTabindex;
+    constructor();
+    isSelected(v: string): boolean;
+    toggle(v: string): void;
+    navigate(currentItem: HTMLElement, action: ListNavigationAction): void;
+    /**
+     * Tabindex policy: with at least one selection, the first selected item
+     * is the entry point; otherwise the first enabled item in DOM order.
+     */
+    isFirstFocusableItem(el: HTMLElement): boolean;
+    registerItem(handle: ForToggleGroupItemHandle): void;
+    unregisterItem(handle: ForToggleGroupItemHandle): void;
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToggleGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForToggleGroup, "[forToggleGroup]", ["forToggleGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * One toggle button inside a `[forToggleGroup]`. Apply on a `<button>`.
+ *
+ * Pressed state is derived from the group's `value`. Click goes through
+ * `group.toggle(value())` so single-vs-multiple semantics live in the
+ * group, not the item.
+ *
+ * Roving tabindex: only one item is in the Tab sequence at a time
+ * (the first selected, or the first enabled when nothing is pressed).
+ * Arrow keys move focus inside the group; the consumer never has to
+ * wire keyboard navigation manually.
+ *
+ * **Composition with [forToolbar]:** when the group is nested inside a
+ * `[forToolbar]`, focus management is delegated to the toolbar — the
+ * tabindex policy and arrow-key navigation flow across all toolbar items
+ * (buttons, links, toggle items) instead of staying confined to the
+ * group. Selection still lives on the group; only focus is shared.
+ */
+declare class ForToggleGroupItem {
+    #private;
+    protected readonly group: forty_cdk_toggle.ForToggleGroupContext;
+    /** Identifier added to / removed from the group's `value`. Required. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Per-item disabled (in addition to the group's `disabled`). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly pressed: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Tabindex per APG: once any item has been focused, the roving tracker owns
+     * the tab stop so re-entry restores the last focused item; before that, fall
+     * back to the entry point (first selected / first enabled). The roving host
+     * is the toolbar when nested inside one, otherwise the group. Disabled items
+     * are always -1.
+     */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    constructor();
+    protected onClick(): void;
+    protected onFocus(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToggleGroupItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForToggleGroupItem, "[forToggleGroupItem]", ["forToggleGroupItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant toggle groups in the surrounding injector
+ * scope. Configure with `provideForToggleDefaults` either at the application
+ * root or in any component's `providers` array; partial overrides merge with
+ * the parent scope.
+ */
+interface ForToggleDefaults {
+    /**
+     * Whether arrow navigation wraps around past the first / last enabled
+     * toggle-group item. Mirrors `ForRadioGroup`'s `loop` default.
+     */
+    loop: boolean;
+}
+/** Token holding the resolved toggle defaults for the current scope. */
+declare const FOR_TOGGLE_DEFAULTS: _angular_core.InjectionToken<ForToggleDefaults>;
+/**
+ * Configures forty-cdk toggle defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForToggleDefaults(defaults?: Partial<ForToggleDefaults>): Provider[];
+
+/**
+ * Exact public names of every `ForToggle` input, its models included. Spread it into the
+ * `inputs` array of a `hostDirectives` entry so a wrapper component re-exposes the
+ * primitive's full surface — the Signal Forms members `[formField]` binds among them —
+ * without hand-maintaining the list. Always spread into an inline object literal as shown
+ * below: the literal is what keeps the entry statically analyzable for consumers compiling
+ * against the published package. An anti-drift spec fails when this list no longer matches
+ * the directive's actual API. See `docs/wrapping-form-primitives.md` for both supported
+ * wrapping patterns.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'button[myToggle]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForToggle,
+ *       inputs: [...FOR_TOGGLE_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_TOGGLE_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MyToggle {}
+ * ```
+ */
+declare const FOR_TOGGLE_HOST_DIRECTIVE_INPUTS: readonly ["checked", "dirty", "disabled", "errors", "invalid", "name", "pending", "readonly", "required", "touched"];
+/**
+ * Exact public names of every `ForToggle` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_TOGGLE_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_TOGGLE_HOST_DIRECTIVE_OUTPUTS: readonly ["checkedChange", "touchedChange", "touch"];
+
+/**
+ * Exact public names of every `ForToggleGroup` input, its models included. Spread it into the
+ * `inputs` array of a `hostDirectives` entry so a wrapper component re-exposes the
+ * primitive's full surface — the Signal Forms members `[formField]` binds among them —
+ * without hand-maintaining the list. Always spread into an inline object literal as shown
+ * below: the literal is what keeps the entry statically analyzable for consumers compiling
+ * against the published package. An anti-drift spec fails when this list no longer matches
+ * the directive's actual API. See `docs/wrapping-form-primitives.md` for both supported
+ * wrapping patterns.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'div[myToggleGroup]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForToggleGroup,
+ *       inputs: [...FOR_TOGGLE_GROUP_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_TOGGLE_GROUP_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MyToggleGroup {}
+ * ```
+ */
+declare const FOR_TOGGLE_GROUP_HOST_DIRECTIVE_INPUTS: readonly ["value", "dir", "dirty", "disabled", "errors", "invalid", "loop", "multiple", "name", "orientation", "pending", "readonly", "required", "touched"];
+/**
+ * Exact public names of every `ForToggleGroup` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_TOGGLE_GROUP_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_TOGGLE_GROUP_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
+
+export { FOR_TOGGLE_DEFAULTS, FOR_TOGGLE_GROUP_CONTEXT, FOR_TOGGLE_GROUP_HOST_DIRECTIVE_INPUTS, FOR_TOGGLE_GROUP_HOST_DIRECTIVE_OUTPUTS, FOR_TOGGLE_HOST_DIRECTIVE_INPUTS, FOR_TOGGLE_HOST_DIRECTIVE_OUTPUTS, ForToggle, ForToggleGroup, ForToggleGroupItem, provideForToggleDefaults };
+export type { ForToggleDefaults, ForToggleGroupContext, ForToggleGroupItemHandle };

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

@@ -0,0 +1,217 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { HostRovingContext, HostRovingItemHandle, WritingDirection, RovingTabindex, ListNavigationAction } from 'forty-cdk/core';
+import * as forty_cdk_toolbar from 'forty-cdk/toolbar';
+
+/**
+ * Per-item handle stored in the toolbar's `Collection`. Buttons, links, and
+ * toggle-group items (when nested) register themselves on construction so the
+ * toolbar can run roving-tabindex and arrow-key navigation in DOM order.
+ *
+ * Extends the lifted `HostRovingItemHandle` so any `_internal/` consumer
+ * that registers against the toolbar via `FOR_HOST_ROVING_CONTEXT` works
+ * without a toolbar-specific handle type.
+ */
+type ForToolbarItemHandle = HostRovingItemHandle;
+/**
+ * Coordination contract owned by `ForToolbar`.
+ *
+ * Extends the neutral `HostRovingContext` (the lifted "host owns roving
+ * navigation for embedded items" contract in `_internal/`) plus
+ * toolbar-specific extras (`loop`). Toolbar provides both
+ * `FOR_TOOLBAR_CONTEXT` and `FOR_HOST_ROVING_CONTEXT` from the same
+ * instance via `useExisting`, so any neutral consumer (e.g.
+ * `ForToggleGroupItem`) and any toolbar-specific consumer pull the same
+ * object without taking a cross-primitive import.
+ */
+interface ForToolbarContext extends HostRovingContext {
+    readonly loop: Signal<boolean>;
+}
+declare const FOR_TOOLBAR_CONTEXT: InjectionToken<ForToolbarContext>;
+
+/**
+ * Headless implementation of the
+ * [WAI-ARIA Toolbar pattern](https://www.w3.org/WAI/ARIA/apg/patterns/toolbar/).
+ *
+ * Hosts buttons, links, separators, and (optionally) a `[forToggleGroup]`
+ * for grouped toggles. Manages roving tabindex across all interactive
+ * children so the toolbar takes a single Tab stop and arrow keys move
+ * focus inside.
+ *
+ * Composition with `ForToggleGroup` is automatic: items inside a
+ * `[forToggleGroup]` whose ancestor is `[forToolbar]` register with the
+ * toolbar's roving and use its keyboard navigation, so arrow keys move
+ * fluidly across the whole bar.
+ *
+ * @example
+ * ```html
+ * <div forToolbar aria-label="Formatting">
+ *   <button forToolbarButton>Undo</button>
+ *   <button forToolbarButton>Redo</button>
+ *   <span forToolbarSeparator></span>
+ *   <div forToggleGroup multiple>
+ *     <button forToggleGroupItem value="bold">B</button>
+ *     <button forToggleGroupItem value="italic">I</button>
+ *   </div>
+ *   <span forToolbarSeparator></span>
+ *   <a forToolbarLink href="/help">Help</a>
+ * </div>
+ * ```
+ */
+declare class ForToolbar implements ForToolbarContext {
+    #private;
+    /**
+     * Manual `aria-label` for the toolbar. Use this when no visible label element
+     * exists; otherwise prefer pointing `aria-labelledby` at one. A `null`
+     * (default) or empty value emits no attribute. Matches the uniform labelling
+     * input on `ForListbox` / `ForMenubar`.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * 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>;
+    /**
+     * Whether arrow navigation wraps around past the first / last enabled
+     * item. Default `true`. The default is read from `provideForToolbarDefaults`
+     * for the surrounding scope.
+     */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Roving-tabindex tracker shared by every toolbar item (buttons, links, and
+     * nested toggle-group items). Items promote themselves to active on
+     * `(focus)` and read `active()` in their tabindex computed, so re-entry
+     * (Shift+Tab back into the toolbar) restores the last focused item —
+     * matching Tabs / Tree. Before any focus, `active()` is `null` and the
+     * tabindex falls back to the first-enabled entry point.
+     */
+    readonly roving: RovingTabindex;
+    constructor();
+    navigate(currentItem: HTMLElement, action: ListNavigationAction): void;
+    isFirstFocusableItem(el: HTMLElement): boolean;
+    registerItem(handle: ForToolbarItemHandle): void;
+    unregisterItem(handle: ForToolbarItemHandle): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToolbar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForToolbar, "[forToolbar]", ["forToolbar"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Plain push button inside `[forToolbar]`. Apply on `<button>` so Enter /
+ * Space activate via native semantics. The directive forces `type="button"`
+ * to avoid accidental form submission inside a `<form>`.
+ */
+declare class ForToolbarButton {
+    #private;
+    protected readonly toolbar: forty_cdk_toolbar.ForToolbarContext | null;
+    /** Per-item disabled (in addition to the toolbar's `disabled`). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Tabindex per APG: once any toolbar item has been focused, the roving
+     * tracker owns the tab stop so re-entry restores the last focused item;
+     * before that, fall back to the first-enabled entry point. Disabled items
+     * are always -1; a button used outside a toolbar keeps its natural 0.
+     */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    constructor();
+    protected onFocus(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToolbarButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForToolbarButton, "[forToolbarButton]", ["forToolbarButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Hyperlink inside `[forToolbar]`. Apply on `<a>`. Honors the toolbar's
+ * roving tabindex and arrow-key navigation; `Enter` follows the link via
+ * native semantics.
+ */
+declare class ForToolbarLink {
+    #private;
+    protected readonly toolbar: forty_cdk_toolbar.ForToolbarContext | null;
+    /**
+     * When true the link is announced as disabled and clicks are suppressed.
+     * Native `<a>` doesn't have a `disabled` attribute — we rely on
+     * `aria-disabled` and prevent navigation in the click handler.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Tabindex per APG: once any toolbar item has been focused, the roving
+     * tracker owns the tab stop so re-entry restores the last focused item;
+     * before that, fall back to the first-enabled entry point. Disabled links
+     * are always -1; a link used outside a toolbar keeps its natural 0.
+     */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    protected onFocus(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToolbarLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForToolbarLink, "[forToolbarLink]", ["forToolbarLink"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Visual separator inside a toolbar. Defaults `orientation` to the opposite
+ * of the toolbar's main axis (a vertical line in a horizontal toolbar, and
+ * vice versa) — pass `orientation` explicitly to override.
+ *
+ * Reflects the same role / aria-orientation / data-orientation contract as
+ * `ForSeparator`, but anchored to the toolbar's cross-axis so an unconfigured
+ * separator renders perpendicular to the toolbar.
+ */
+declare class ForToolbarSeparator {
+    #private;
+    /**
+     * Axis the separator divides along. When omitted, falls back to the
+     * cross-axis of the parent toolbar (horizontal toolbar → vertical
+     * separator, and vice versa).
+     */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical" | undefined>;
+    /**
+     * When true, the separator is purely visual: it gets `role="none"` and no
+     * `aria-orientation`, so assistive tech treats surrounding content as a
+     * single flow.
+     */
+    readonly decorative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Cross-axis of the parent toolbar — the orientation an unconfigured
+     * separator inherits.
+     */
+    readonly defaultOrientation: _angular_core.Signal<"horizontal" | "vertical">;
+    protected readonly effectiveOrientation: _angular_core.Signal<"horizontal" | "vertical">;
+    protected ariaOrientation(): 'vertical' | null;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForToolbarSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForToolbarSeparator, "[forToolbarSeparator]", ["forToolbarSeparator"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant toolbars in the surrounding injector
+ * scope. Configure with `provideForToolbarDefaults` either at the
+ * application root or in any component's `providers` array; partial
+ * overrides merge with the parent scope.
+ */
+interface ForToolbarDefaults {
+    /**
+     * Whether arrow navigation wraps around past the first / last enabled
+     * item. Matches the WAI-ARIA Toolbar APG default.
+     */
+    loop: boolean;
+}
+/** Token holding the resolved toolbar defaults for the current scope. */
+declare const FOR_TOOLBAR_DEFAULTS: _angular_core.InjectionToken<ForToolbarDefaults>;
+/**
+ * Configures forty-cdk toolbar defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForToolbarDefaults(defaults?: Partial<ForToolbarDefaults>): Provider[];
+
+export { FOR_TOOLBAR_CONTEXT, FOR_TOOLBAR_DEFAULTS, ForToolbar, ForToolbarButton, ForToolbarLink, ForToolbarSeparator, provideForToolbarDefaults };
+export type { ForToolbarContext, ForToolbarDefaults, ForToolbarItemHandle };