accordion headless API

export declare const Accordion: {
  Root: import("react").ForwardRefExoticComponent<AccordionRootProps & import("react").RefAttributes<HTMLDivElement>>;
  Item: import("react").ForwardRefExoticComponent<AccordionItemProps & import("react").RefAttributes<HTMLDivElement>>;
  Heading: import("react").ForwardRefExoticComponent<AccordionHeadingProps & import("react").RefAttributes<HTMLHeadingElement>>;
  Trigger: import("react").ForwardRefExoticComponent<AccordionTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Content: import("react").ForwardRefExoticComponent<AccordionContentProps & import("react").RefAttributes<HTMLDivElement>>;
};

interface AccordionContentProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly item: AccordionItem<AccordionItemValue>;
}

export declare const AccordionContext: import("react").Context<AccordionContextValue | null>;

interface AccordionContextValue {
  readonly service: AccordionService;
  readonly connector: AccordionApi;
  readonly scope: PartScope;
}

interface AccordionHeadingProps extends ComponentPropsWithoutRef<"h3"> {
  readonly asChild?: boolean;
  readonly item: AccordionItem<AccordionItemValue>;
}

interface AccordionItemProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly item: AccordionItem<AccordionItemValue>;
}

interface AccordionRootProps extends Omit<ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "onChange"> {
  readonly asChild?: boolean;
  readonly items: AccordionInput["items"];
  readonly type?: AccordionInput["type"];
  readonly value?: AccordionInput["value"];
  readonly defaultValue?: AccordionInput["defaultValue"];
  readonly collapsible?: AccordionInput["collapsible"];
  readonly onValueChange?: (detail: AccordionValueChangeDetail) => void;
  readonly children?: ReactNode;
}

interface AccordionTriggerProps extends Omit<ComponentPropsWithoutRef<"button">, "type"> {
  readonly asChild?: boolean;
  readonly item: AccordionItem<AccordionItemValue>;
}

interface AccordionValueChangeDetail {
  readonly value: readonly string[];
  readonly reason: AccordionChangeReason;
}

export declare const Content: import("react").ForwardRefExoticComponent<AccordionContentProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Heading: import("react").ForwardRefExoticComponent<AccordionHeadingProps & import("react").RefAttributes<HTMLHeadingElement>>;

export declare const Item: import("react").ForwardRefExoticComponent<AccordionItemProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Root: import("react").ForwardRefExoticComponent<AccordionRootProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Trigger: import("react").ForwardRefExoticComponent<AccordionTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;

declare function useAccordion(input: AccordionInput, options?: UseAccordionOptions): UseAccordionResult;

declare function useAccordionContext(partName: string): AccordionContextValue;

interface UseAccordionOptions {
  readonly onValueChange?: (detail: AccordionValueChangeDetail) => void;
}

interface UseAccordionResult {
  readonly service: AccordionService;
  readonly connector: AccordionApi;
  readonly scope: PartScope;
  readonly snapshot: AccordionSnapshot;
}

declare function useServiceVersion<S extends Service<any, any, any, any, any, any>>(service: S): ReturnType<S["getSnapshot"]>;

export declare const AccordionContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const AccordionContextKey: InjectionKey<AccordionContextValue>;

interface AccordionContextValue {
  readonly service: AccordionService;
  readonly connector: AccordionApi;
  readonly scope: PartScope;
  /** Bumped on every committed machine update; parts read `.value` to establish a reactive dependency. */
  readonly snapshot: ShallowRef<AccordionSnapshot>;
}

export declare const AccordionHeading: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const AccordionItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const AccordionRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  items: {
    type: PropType<AccordionInput["items"]>;
    required: true;
  };
  type: {
    type: PropType<AccordionInput["type"]>;
    default: undefined;
  };
  value: {
    type: PropType<readonly AccordionItemValue[] | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<readonly AccordionItemValue[] | undefined>;
    default: undefined;
  };
  collapsible: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: AccordionValueChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  items: {
    type: PropType<AccordionInput["items"]>;
    required: true;
  };
  type: {
    type: PropType<AccordionInput["type"]>;
    default: undefined;
  };
  value: {
    type: PropType<readonly AccordionItemValue[] | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<readonly AccordionItemValue[] | undefined>;
    default: undefined;
  };
  collapsible: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
}>> & Readonly<{
  onValueChange?: ((_detail: AccordionValueChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  type: import("@grassroot/ui-machines/accordion").AccordionType | undefined;
  value: readonly string[] | undefined;
  defaultValue: readonly string[] | undefined;
  collapsible: boolean | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const AccordionTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  item: {
    type: PropType<AccordionItem$1>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

interface AccordionValueChangeDetail {
  readonly value: readonly string[];
  readonly reason: AccordionChangeReason;
}

declare function useAccordion(input: AccordionInput | (() => AccordionInput), options?: UseAccordionOptions): UseAccordionResult;

declare function useAccordionContext(partName: string): AccordionContextValue;

interface UseAccordionOptions {
  readonly onValueChange?: (detail: AccordionValueChangeDetail) => void;
}

interface UseAccordionResult {
  readonly service: AccordionService;
  readonly connector: AccordionApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<AccordionSnapshot>;
}

export declare const ACCORDION_STORE: InjectionToken<AccordionStore>;

export interface AccordionStore {
    readonly service: AccordionService;
    readonly connector: AccordionApi;
    readonly scope: PartScope;
    /**
     * Bumped on every committed machine update. Effects that read the
     * connector's prop bags must read this signal first — inside the same
     * `effect()` — so Angular's reactivity re-runs the effect on every
     * committed change (the staleness bug class called out across every
     * other adapter).
     */
    readonly version: WritableSignal<number>;
    /** Starts the underlying service (idempotent) — call from the browser only. */
    start(): void;
    /** Stops the underlying service (idempotent). */
    stop(): void;
    /** Forwards a new committed input to the machine (no-op on the very first call). */
    sync(input: AccordionInput): void;
}

export interface AccordionValueChangeDetail {
    readonly value: readonly string[];
    readonly reason: AccordionChangeReason;
}

export declare function createAccordionStore(initialInput: AccordionInput, options?: CreateAccordionStoreOptions): AccordionStore;

export interface CreateAccordionStoreOptions {
    readonly onValueChange?: (detail: AccordionValueChangeDetail) => void;
    /**
     * Called synchronously right after `version` is bumped on every committed
     * machine update — see `../tabs/use-tabs.ts`'s `CreateTabsStoreOptions.onCommit`
     * doc comment for the exact race it closes (Angular's zoneless `effect()`
     * flush vs. a script dispatching two events back to back). `GrAccordionRoot`
     * wires this to `ApplicationRef.tick()`.
     */
    readonly onCommit?: () => void;
}

export declare const GR_ACCORDION_DECLARATIONS: readonly [typeof GrAccordionRoot, typeof GrAccordionItem, typeof GrAccordionHeading, typeof GrAccordionTrigger, typeof GrAccordionContent];

export declare class GrAccordionContent implements OnDestroy {
    readonly item: import("@angular/core").InputSignal<AccordionItem<string>>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registeredKey;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAccordionContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAccordionContent, "[grAccordionContent]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export declare class GrAccordionHeading {
    readonly item: import("@angular/core").InputSignal<AccordionItem<string>>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAccordionHeading, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAccordionHeading, "[grAccordionHeading]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export declare class GrAccordionItem {
    readonly item: import("@angular/core").InputSignal<AccordionItem<string>>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAccordionItem, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAccordionItem, "[grAccordionItem]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}