import * as _angular_core from '@angular/core';
import { InjectionToken, 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]`.
 *
 * A read-only toggle is reflected as the boolean `data-readonly` styling hook
 * only: `aria-readonly` is not a supported property of `role="button"`, so
 * there is no ARIA channel for the state on a toggle button. Click stays a
 * no-op and the button stays focusable. `required` is reflected the same way,
 * as `data-required`, for the same reason.
 *
 * @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 {
    protected readonly buttonType: _angular_core.Signal<string | null>;
    /**
     * 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, "button[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 {
    /**
     * Narrowed from {@link CollectionHandle}'s `Node`: the group focuses the item
     * and queries it against the roving-tabindex tracker.
     */
    readonly host: HTMLElement;
    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 {
    /**
     * The current selection, as a read-only signal. Mutate it through `toggle`
     * or the root's `[(value)]` binding — a direct write would bypass the group's
     * disabled guard and single/multiple mode rules.
     */
    readonly value: Signal<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.
 *
 * A read-only group is reflected as the boolean `data-readonly` styling hook
 * on this root only: `aria-readonly` is a supported property of neither
 * `role="group"` nor the items' `role="button"`, so there is no ARIA channel
 * for the state. Clicks stay no-ops and the items stay focusable.
 *
 * `required` is reflected the same way, as `data-required` on the root.
 */
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();
    /**
     * Move focus to a toggle item, implementing `FormValueControl.focus` from
     * `@angular/forms/signals`. Without this override Signal Forms would focus the
     * host `role="group"` wrapper — which is not focusable — so focus-on-error
     * would silently go nowhere. Targets the first selected item's host when one
     * is pressed, else the first enabled item's host; no-op when disabled or when
     * no enabled item exists.
     */
    focus(options?: FocusOptions): void;
    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 buttonType: _angular_core.Signal<string | null>;
    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, "button[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 };