import * as _angular_core from '@angular/core';
import { TemplateRef, InjectionToken, Signal, ElementRef } from '@angular/core';

/**
 * Single tab. Two modes, decided by inputs:
 *
 * - **Content tab** — projected children render in the parent's content
 *   panel when this tab is active.
 * - **Router tab** — set `routerLink` and the tab becomes a link; the
 *   parent skips its content panel and the consumer drops a
 *   `<router-outlet>` below the tab strip.
 */
declare class WrTab {
    /** Visible label on the tab strip. */
    readonly title: _angular_core.InputSignal<string>;
    /**
     * Stable identifier used by the parent to track the active tab.
     * Auto-generated if omitted.
     */
    readonly key: _angular_core.InputSignal<string>;
    /** Router target — when set, the tab becomes a `[routerLink]` link. */
    readonly routerLink: _angular_core.InputSignal<string | readonly string[] | null>;
    /** Disable the tab. */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
    /** Tab content template; portaled into the parent's panel area. @internal */
    readonly contentTpl: _angular_core.Signal<TemplateRef<any>>;
    private readonly parent;
    private readonly destroyRef;
    protected readonly isRouter: _angular_core.Signal<boolean>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTab, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTab, "wr-tab", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * @license
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
 */

/**
 * Contract a `<wr-tab>` uses to talk to its parent `<wr-tabs>`.
 *
 * @internal
 */
interface WrTabsContext {
    /** Currently active tab key (component-managed only). */
    readonly active: Signal<string | null>;
    /** Activate a tab by key (component-managed only). */
    activate(key: string): void;
    /** Register a child tab so the parent can pick a default. */
    register(tab: {
        key: string;
        routerLink: unknown;
    }): void;
    /** Unregister on destroy. */
    unregister(key: string): void;
}
/**
 * Token a `<wr-tab>` injects to register itself with — and read the active
 * key from — its parent `<wr-tabs>` host.
 *
 * @internal
 */
declare const WR_TABS: InjectionToken<WrTabsContext>;

/**
 * Tabbed container. Two modes depending on the child `<wr-tab>`
 * definitions:
 *
 * - **Content** — children project body content; the parent renders an
 *   active-tab panel automatically.
 * - **Router** — any child with `routerLink` switches the whole strip
 *   into router mode; the parent skips its panel so the consumer can
 *   drop a `<router-outlet>` after it.
 *
 * @example
 * ```html
 * <!-- content tabs -->
 * <wr-tabs [(active)]="key">
 *   <wr-tab key="one" title="One">First panel</wr-tab>
 *   <wr-tab key="two" title="Two">Second panel</wr-tab>
 * </wr-tabs>
 *
 * <!-- router tabs -->
 * <wr-tabs>
 *   <wr-tab title="Overview" routerLink="overview" />
 *   <wr-tab title="Details" routerLink="details" />
 * </wr-tabs>
 * <router-outlet />
 * ```
 *
 * @see https://ngwr.dev/components/tabs
 */
declare class WrTabs implements WrTabsContext {
    /** Two-way bindable active tab key (content mode). */
    readonly active: _angular_core.ModelSignal<string | null>;
    /** Visual size variant. */
    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
    protected readonly tabs: _angular_core.Signal<readonly WrTab[]>;
    /** When any child has a routerLink, the whole strip switches to router mode. */
    protected readonly isRouter: _angular_core.Signal<boolean>;
    /** Content-mode: the tab whose key matches `active()` (or the first tab if none yet). */
    protected readonly activeTab: _angular_core.Signal<WrTab | null>;
    activate(key: string): void;
    register({ key }: {
        key: string;
        routerLink: unknown;
    }): void;
    unregister(): void;
    protected readonly stripRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    /** Whether the strip is scrolled away from its start / end — drives the edge fades. */
    protected readonly canScrollStart: _angular_core.WritableSignal<boolean>;
    protected readonly canScrollEnd: _angular_core.WritableSignal<boolean>;
    constructor();
    /** Recompute which edges can scroll, from the strip's scroll metrics. @internal */
    protected updateFades(): void;
    protected onTabClick(tab: WrTab): void;
    /** Header id for `aria-labelledby` on the panel. @internal */
    headerId(key: string): string;
    /** Panel id for `aria-controls` on the tab header. @internal */
    panelId(key: string): string;
    /** ArrowLeft/Right/Home/End keyboard navigation on the tab strip. */
    protected onStripKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTabs, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTabs, "wr-tabs", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, ["tabs"], never, true, never>;
}

export { WR_TABS, WrTab, WrTabs };
export type { WrTabsContext };