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

/**
 * Expandable panel with a clickable header. Two-way binds the `open`
 * state. When wrapped in `<wr-collapse-group accordion>`, only one
 * sibling can be open at a time.
 *
 * @example
 * ```html
 * <wr-collapse title="Section title">
 *   Section body…
 * </wr-collapse>
 *
 * <wr-collapse-group accordion>
 *   <wr-collapse title="A">…</wr-collapse>
 *   <wr-collapse title="B">…</wr-collapse>
 * </wr-collapse-group>
 * ```
 *
 * @see https://ngwr.dev/components/collapse
 */
declare class WrCollapse {
    /** Header text. */
    readonly title: _angular_core.InputSignal<string>;
    /** Two-way bindable open/closed state. @default false */
    readonly open: _angular_core.ModelSignal<boolean>;
    /** Disable interaction. @default false */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
    /** Identity used by the parent group when tracking children. @internal */
    readonly id: {
        name: string;
    };
    /** DOM id for the body element, referenced by header's `aria-controls`. */
    protected readonly bodyId: string;
    private readonly group;
    private readonly destroyRef;
    protected readonly classes: _angular_core.Signal<string>;
    constructor();
    /** Open the panel. */
    openPanel(): void;
    /** Close the panel. */
    close(): void;
    /** Toggle the panel. */
    toggle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCollapse, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCollapse, "wr-collapse", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, 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 collapse uses to talk to its parent `<wr-collapse-group>`.
 *
 * @internal
 */
interface WrCollapseGroupContext {
    /** When true, only one child collapse may be open at a time. */
    readonly accordion: Signal<boolean>;
    /** Called by a child when it opens — closes siblings in accordion mode. */
    notifyOpened(opener: object): void;
    /** Register a child so the group can call `closeAll()` etc. */
    register(member: {
        close(): void;
        readonly id: object;
    }): void;
    /** Unregister on destroy. */
    unregister(memberId: object): void;
}
/**
 * Token a `<wr-collapse>` injects to register itself with — and notify of
 * open events — its parent `<wr-collapse-group>`. Drives the accordion
 * behaviour when the group has `accordion` enabled.
 *
 * @internal
 */
declare const WR_COLLAPSE_GROUP: InjectionToken<WrCollapseGroupContext>;

interface Member$1 {
    close(): void;
    readonly id: object;
}
/**
 * Visual + behavioral grouping of `<wr-collapse>` children. When
 * `accordion` is true, opening one child closes the others.
 *
 * @see https://ngwr.dev/components/collapse
 */
declare class WrCollapseGroup implements WrCollapseGroupContext {
    /** When true, only one child may be open at a time. @default false */
    readonly accordion: _angular_core.InputSignalWithTransform<boolean, any>;
    private readonly members;
    register(member: Member$1): void;
    unregister(memberId: object): void;
    notifyOpened(opener: object): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCollapseGroup, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCollapseGroup, "wr-collapse-group", never, { "accordion": { "alias": "accordion"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

interface Member {
    close(): void;
    readonly id: object;
}
/**
 * Accordion — a `<wr-collapse>` container that enforces single-open
 * behavior: opening a child closes its siblings.
 *
 * Use `<wr-collapse-group>` when you only need visual grouping without
 * the mutually-exclusive open semantics.
 *
 * @example
 * ```html
 * <wr-accordion>
 *   <wr-collapse title="Profile">…</wr-collapse>
 *   <wr-collapse title="Security">…</wr-collapse>
 *   <wr-collapse title="Notifications">…</wr-collapse>
 * </wr-accordion>
 * ```
 *
 * @see https://ngwr.dev/components/collapse
 */
declare class WrAccordion implements WrCollapseGroupContext {
    /** Always behaves as an accordion. Provided for context-interface symmetry. */
    readonly accordion: _angular_core.Signal<boolean>;
    private readonly members;
    register(member: Member): void;
    unregister(memberId: object): void;
    notifyOpened(opener: object): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrAccordion, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrAccordion, "wr-accordion", never, {}, {}, never, ["*"], true, never>;
}

export { WR_COLLAPSE_GROUP, WrAccordion, WrCollapse, WrCollapseGroup };
export type { WrCollapseGroupContext };