import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Provider } from '@angular/core';
import { WritingDirection, RovingTabindex, ListNavigationAction } from 'forty-cdk/core';

type TabsActivationMode = 'automatic' | 'manual';
/**
 * Registry entry for one `ForTabsTrigger`. Part of the registration protocol,
 * so it is never exported from `public-api.ts` — see {@link TabsContext}.
 */
interface ForTabsTriggerHandle {
    readonly host: HTMLElement;
    readonly id: Signal<string>;
    readonly value: Signal<string>;
    readonly disabled: Signal<boolean>;
}
/**
 * Registry entry for one `ForTabsContent`. Part of the registration protocol,
 * so it is never exported from `public-api.ts` — see {@link TabsContext}.
 */
interface ForTabsContentHandle {
    readonly host: HTMLElement;
    readonly id: Signal<string>;
    readonly value: Signal<string>;
}
/**
 * Coordination contract owned by `ForTabs`. Triggers and contents register
 * with the root so each side can look up its pair (for `aria-controls` and
 * `aria-labelledby` wiring), and the root drives keyboard navigation.
 */
interface ForTabsContext {
    readonly value: Signal<string | null>;
    readonly disabled: Signal<boolean>;
    readonly orientation: Signal<'horizontal' | 'vertical'>;
    readonly dir: Signal<WritingDirection>;
    readonly activationMode: Signal<TabsActivationMode>;
    readonly roving: RovingTabindex;
    isSelected(value: string): boolean;
    /** Selects `value` if the tabs widget is interactive. */
    select(value: string): void;
    /** Moves focus from `currentTrigger`. In automatic mode also selects the new tab. */
    navigate(currentTrigger: HTMLElement, action: ListNavigationAction): void;
    /**
     * Looks up the trigger id for a given tab value. Reactive.
     *
     * Triggers and contents register synchronously in their constructors, so the
     * pairing resolves during the first change-detection pass — including a real
     * server render, where `afterNextRender` never fires and a deferred
     * registration would leave the pre-hydration DOM without its
     * `aria-labelledby` / `aria-controls` linkage. A handle whose `value` binding
     * has not been written yet reads the `unsetInput` sentinel and is skipped —
     * it can never pair with a lookup value — and the tracked dependency re-runs
     * the lookup once that binding lands.
     */
    triggerIdFor(value: string): string | null;
    /**
     * Looks up the content id for a given tab value. Reactive. Same
     * synchronous-registration and not-yet-bound handling as
     * {@link triggerIdFor}.
     */
    contentIdFor(value: string): string | null;
    /** True when `el` is the first enabled trigger in registration order. */
    isFirstEnabledTrigger(el: HTMLElement): boolean;
    /**
     * True when some registered, enabled trigger matches the current `value`.
     * Distinguishes "another trigger owns the tab stop" from "the selected
     * value points at a removed / disabled trigger" so the per-trigger
     * tabindex fallback can re-engage the first-enabled entry point instead of
     * stranding the tablist. Reactive.
     */
    hasSelectedTrigger(): boolean;
}
/**
 * DI token for the tabs widget's coordination surface, provided by `[forTabs]`.
 *
 * Publicly typed as the read surface {@link ForTabsContext}, which is the whole of what the
 * token promises a consumer. The pieces read the same token at an internal type that adds
 * the trigger / content registration protocol, so a wrapper re-providing it must alias it to
 * the root: `{ provide: FOR_TABS_CONTEXT, useExisting: MyTabs }`, where `MyTabs` extends
 * `ForTabs`. A value that merely satisfies the declared type resolves too, and is rejected
 * in dev mode by the first piece to reach the protocol.
 */
declare const FOR_TABS_CONTEXT: InjectionToken<ForTabsContext>;
/**
 * The tabs widget's internal coordination surface: everything
 * {@link ForTabsContext} publishes plus the trigger / content registration
 * protocol the id pairing and keyboard navigation are driven from.
 *
 * Never exported from `public-api.ts`. It is the type the pieces read
 * {@link FOR_TABS_CONTEXT} at, so a consumer who injects that token gets the
 * read surface while the pieces get the wiring protocol. `ForTabs` declares the
 * protocol members TS-`private`, which keeps them out of the emitted `.d.ts`
 * while `useExisting` still satisfies this contract at runtime.
 */
interface TabsContext extends ForTabsContext {
    registerTrigger(handle: ForTabsTriggerHandle): void;
    unregisterTrigger(handle: ForTabsTriggerHandle): void;
    registerContent(handle: ForTabsContentHandle): void;
    unregisterContent(handle: ForTabsContentHandle): void;
}

/**
 * Root of the Tabs primitive. Owns the selected value, activation mode,
 * orientation, and disabled state. Provides the shared context to descendant
 * `ForTabsList` / `ForTabsTrigger` / `ForTabsContent` directives.
 *
 * Implements the [WAI-ARIA Tabs pattern](https://www.w3.org/WAI/ARIA/apg/patterns/tabs/).
 *
 * `activationMode='automatic'` (default): arrow nav moves focus AND selects
 * the new tab. Use when panel content is cheap to render.
 * `activationMode='manual'`: arrow nav only moves focus; the user must press
 * Space / Enter to activate. Use when panel content is expensive.
 */
declare class ForTabs implements ForTabsContext {
    #private;
    /**
     * Two-way bindable. The selected tab's value, or `null` when nothing is
     * selected. `null` is the canonical unset state — distinct from a tab whose
     * `value` is the empty string `''`, which is a legal, selectable value. The
     * `model()` change emitter (`(valueChange)`) fires only on internal
     * selection changes (trigger click or automatic-mode arrow nav), never on
     * consumer writes via `[(value)]` — observe transitions without binding back.
     */
    readonly value: _angular_core.ModelSignal<string | null>;
    /**
     * Whether arrow navigation also selects the focused tab (`'automatic'`, the default) or only
     * moves focus until the user presses Enter or Space (`'manual'`). The default is read from
     * `provideForTabsDefaults` for the surrounding scope.
     */
    readonly activationMode: _angular_core.InputSignal<TabsActivationMode>;
    /**
     * Axis the arrow keys navigate. Reflected as `data-orientation`.
     */
    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 every trigger in the list is disabled. Individual triggers may also disable themselves.
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether arrow navigation wraps around past the first / last enabled
     * trigger. Default `true` — matches the WAI-ARIA Tabs APG. Set to `false`
     * for a non-wrapping tablist. The default is read from
     * `provideForTabsDefaults` for the surrounding scope.
     */
    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly roving: RovingTabindex;
    isSelected(v: string): boolean;
    select(v: string): void;
    navigate(currentTrigger: HTMLElement, action: ListNavigationAction): void;
    private registerTrigger;
    private unregisterTrigger;
    private registerContent;
    private unregisterContent;
    triggerIdFor(value: string): string | null;
    contentIdFor(value: string): string | null;
    isFirstEnabledTrigger(el: HTMLElement): boolean;
    hasSelectedTrigger(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTabs, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTabs, "[forTabs]", ["forTabs"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
}

/**
 * The `role="tablist"` container — wraps the `ForTabsTrigger` elements (and
 * only those — panels live as siblings of the list). Reflects the parent's
 * orientation as `aria-orientation`.
 */
declare class ForTabsList {
    protected readonly group: TabsContext;
    /** Accessible name for the tab 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<ForTabsList, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTabsList, "[forTabsList]", ["forTabsList"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Header button for one tab. Apply on a `<button type="button">` so Enter /
 * Space activation come from native button behavior.
 *
 * Tabindex follows APG: the user-focused trigger owns `tabindex=0` (tracked
 * by `RovingTabindex`); before any interaction, the selected trigger (or
 * first enabled, when nothing is selected) is the tab entry.
 *
 * `aria-controls` is emitted whenever a matching panel is registered — APG
 * emits it on every tab, which for the keep-mounted default means every
 * trigger. For consumers who unmount inactive panels via `@if (selected())`
 * it collapses to only the mounted trigger, so the reference never dangles at
 * an absent panel either way.
 */
declare class ForTabsTrigger {
    #private;
    protected readonly buttonType: _angular_core.Signal<string | null>;
    protected readonly group: TabsContext;
    /**
     * Value this trigger selects, paired with the `[forTabsContent]` carrying the same value.
     * Mandatory — an unbound trigger throws in dev mode.
     */
    readonly value: _angular_core.InputSignal<string>;
    /**
     * Whether this trigger can be activated. A disabled trigger stays focusable and announced, and is
     * skipped by arrow navigation.
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly id: _angular_core.Signal<string>;
    readonly selected: _angular_core.Signal<boolean>;
    readonly effectiveDisabled: _angular_core.Signal<boolean>;
    protected readonly controlsId: _angular_core.Signal<string | null>;
    /**
     * APG tabindex: user-driven roving owns it once any trigger has been
     * focused. Before that, fall back to "selected, else first enabled".
     */
    protected readonly tabindex: _angular_core.Signal<0 | -1>;
    constructor();
    protected onClick(): void;
    protected onFocus(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTabsTrigger, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTabsTrigger, "[forTabsTrigger]", ["forTabsTrigger"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Panel for one tab. The directive does not manage DOM presence — leave the
 * panel mounted (idiomatic for tabs, preserves scroll/input state across
 * activations) and either toggle visibility in CSS via
 * `[data-state="inactive"]` or wrap with `@if (selected())` to unmount it.
 * While inactive, the directive reflects `aria-hidden="true"` and `inert`
 * so the mounted-but-inactive panel is removed from the accessibility tree
 * and focus order automatically.
 *
 * APG: a `tabpanel` is a tab stop (`tabindex="0"`) **only** when it has no
 * focusable content of its own — that lets screen-reader users reach an
 * otherwise-unreachable panel, while a panel that already contains a form,
 * links, or buttons does not add a redundant tab stop. The directive detects
 * focusable descendants automatically (reactive to subtree changes); set
 * `[interactiveContent]` to override the detection in either direction.
 */
declare class ForTabsContent {
    #private;
    protected readonly group: TabsContext;
    /**
     * Value of the tab this panel belongs to, paired with the `[forTabsTrigger]` carrying the same
     * value. Mandatory — an unbound panel throws in dev mode.
     */
    readonly value: _angular_core.InputSignal<string>;
    /**
     * Overrides the automatic focusable-content detection that drives the
     * panel's `tabindex`. Leave unset (default `null`) to let the directive
     * decide: a panel with no focusable descendants gets `tabindex="0"` so it
     * is reachable by Tab, a panel with focusable descendants gets none. Set
     * `true` when the panel always holds its own focusable content, `false` to
     * force the panel to be a tab stop regardless of its content.
     *
     * The override decides the attribute only; the detection itself runs either
     * way. That makes it the way out of an answer the observer cannot re-measure
     * — focusable content inside a shadow root, or a visibility flip driven
     * purely by a stylesheet — both of which the README's _Known limitations_
     * covers.
     */
    readonly interactiveContent: _angular_core.InputSignalWithTransform<boolean | null, unknown>;
    readonly id: _angular_core.Signal<string>;
    readonly selected: _angular_core.Signal<boolean>;
    protected readonly labelledBy: _angular_core.Signal<string | null>;
    /**
     * APG tabindex: `0` only when the panel has no focusable content of its
     * own, so SR users can focus the panel itself; otherwise no `tabindex`
     * attribute, so the panel does not add a redundant tab stop. An explicit
     * `interactiveContent` wins over the automatic detection.
     */
    protected readonly tabindex: _angular_core.Signal<"0" | null>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTabsContent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTabsContent, "[forTabsContent]", ["forTabsContent"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "interactiveContent": { "alias": "interactiveContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Defaults inherited by descendant tabs in the surrounding injector scope.
 * Configure with `provideForTabsDefaults` either at the application root
 * or in any component's `providers` array; partial overrides merge with
 * the parent scope.
 */
interface ForTabsDefaults {
    /**
     * `'automatic'` (default): arrow navigation moves focus AND selects the
     * new tab. Use when panel content is cheap to render. `'manual'`: arrow
     * navigation only moves focus; the user must press Space / Enter to
     * activate. Use when panel content is expensive.
     */
    activationMode: TabsActivationMode;
    /**
     * Whether arrow navigation wraps around past the first / last enabled
     * trigger. Matches the WAI-ARIA Tabs APG default.
     */
    loop: boolean;
}
/** Token holding the resolved tabs defaults for the current scope. */
declare const FOR_TABS_DEFAULTS: _angular_core.InjectionToken<ForTabsDefaults>;
/**
 * Configures forty-cdk tabs defaults for this injector scope. Partial
 * overrides inherit unspecified keys from the parent scope (or library
 * defaults at the root).
 */
declare function provideForTabsDefaults(defaults?: Partial<ForTabsDefaults>): Provider[];

export { FOR_TABS_CONTEXT, FOR_TABS_DEFAULTS, ForTabs, ForTabsContent, ForTabsList, ForTabsTrigger, provideForTabsDefaults };
export type { ForTabsContext, ForTabsDefaults, TabsActivationMode };