reveal headless API

export declare const Reveal: {
  Root: import("react").ForwardRefExoticComponent<RevealRootProps & import("react").RefAttributes<HTMLElement>>;
};

interface RevealChangeDetail {
  readonly reason: RevealReason;
}

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

interface RevealContextValue {
  readonly service: RevealService;
  readonly connector: RevealApi;
  readonly scope: PartScope;
}

interface RevealRootProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
  readonly asChild?: boolean;
  readonly as?: string;
  readonly onRevealed?: (detail: RevealChangeDetail) => void;
  readonly evaluateViewportOnStart?: boolean;
  readonly host?: UseRevealOptions["host"];
  readonly scheduler?: UseRevealOptions["scheduler"];
  readonly children?: ReactNode;
}

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

declare function useReveal(input?: RevealInput, options?: UseRevealOptions): UseRevealResult;

declare function useRevealContext(partName: string): RevealContextValue;

interface UseRevealOptions {
  readonly onRevealed?: (detail: RevealChangeDetail) => void;
  readonly scheduler?: Scheduler;
  /** When false, skip the synchronous in-viewport check (styled React first paint). */
  readonly evaluateViewportOnStart?: boolean;
  /** Test/SSR host overrides (observer, matchMedia). `getElement` stays adapter-owned. */
  readonly host?: Partial<Omit<RevealControllerHost, "getElement">>;
}

interface UseRevealResult {
  readonly service: RevealService;
  readonly connector: RevealApi;
  readonly scope: PartScope;
  readonly snapshot: RevealSnapshot;
}

interface RevealChangeDetail {
  readonly reason: RevealReason;
}

export declare const RevealContextKey: InjectionKey<RevealContextValue>;

interface RevealContextValue {
  readonly service: RevealService;
  readonly connector: RevealApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<RevealSnapshot>;
}

export declare const RevealRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  as: {
    type: StringConstructor;
    default: string;
  };
  evaluateViewportOnStart: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  host: {
    type: PropType<UseRevealOptions["host"]>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseRevealOptions["scheduler"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  revealed: (_detail: RevealChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  as: {
    type: StringConstructor;
    default: string;
  };
  evaluateViewportOnStart: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  host: {
    type: PropType<UseRevealOptions["host"]>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseRevealOptions["scheduler"]>;
    default: undefined;
  };
}>> & Readonly<{
  onRevealed?: ((_detail: RevealChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  as: string;
  evaluateViewportOnStart: boolean | undefined;
  host: Partial<Omit<import("@grassroot/ui-headless-core/reveal").RevealControllerHost, "getElement">> | undefined;
  scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function useReveal(input?: RevealInput | (() => RevealInput), options?: UseRevealOptions): UseRevealResult;

declare function useRevealContext(partName: string): RevealContextValue;

interface UseRevealOptions {
  readonly onRevealed?: (detail: RevealChangeDetail) => void;
  readonly scheduler?: Scheduler;
  readonly evaluateViewportOnStart?: boolean;
  readonly host?: Partial<Omit<RevealControllerHost, "getElement">>;
}

interface UseRevealResult {
  readonly service: RevealService;
  readonly connector: RevealApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<RevealSnapshot>;
}

export declare function createRevealStore(initialInput?: RevealInput, options?: CreateRevealStoreOptions): RevealStore;

export interface CreateRevealStoreOptions {
    readonly onRevealed?: (detail: RevealChangeDetail) => void;
    readonly onCommit?: () => void;
    readonly scheduler?: Scheduler;
    readonly evaluateViewportOnStart?: boolean;
    readonly host?: Partial<Omit<RevealControllerHost, "getElement">>;
}

export declare const GR_REVEAL_DECLARATIONS: readonly [typeof GrRevealRoot];

export declare class GrRevealRoot implements OnDestroy {
    readonly revealed: import("@angular/core").OutputEmitterRef<RevealChangeDetail>;
    private readonly element;
    private readonly injector;
    private readonly listeners;
    readonly store: RevealStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRevealRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrRevealRoot, "gr-reveal-root", never, {}, { "revealed": "revealed"; }, never, ["*"], true, never>;
}

export declare function provideRevealStore(): Provider;

export declare const REVEAL_HOST: InjectionToken<Partial<Omit<RevealControllerHost, "getElement">>>;

export declare const REVEAL_SCHEDULER: InjectionToken<Scheduler>;

export declare const REVEAL_STORE: InjectionToken<RevealStore>;

export interface RevealChangeDetail {
    readonly reason: RevealReason;
}

export interface RevealStore {
    readonly service: RevealService;
    readonly connector: RevealApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: RevealInput): void;
    bindRevealed(handler: (detail: RevealChangeDetail) => void): void;
}

export declare function createReveal(inputGetter?: () => RevealInput, options?: UseRevealOptions): UseRevealResult;

export interface RevealChangeDetail {
    readonly reason: RevealReason;
}

export interface RevealContextValue {
    readonly service: RevealService;
    readonly connector: RevealApi;
    readonly scope: PartScope;
    readonly version: () => number;
}

export declare const RevealRoot: LegacyComponentType;

export declare function splitProps(props: PartProps): SplitProps;

export declare function useRevealContext(partName: string): RevealContextValue;

export interface UseRevealOptions {
    readonly onRevealed?: (detail: RevealChangeDetail) => void;
    readonly scheduler?: Scheduler;
    readonly evaluateViewportOnStart?: boolean;
    readonly host?: Partial<Omit<RevealControllerHost, "getElement">>;
}

export interface UseRevealResult {
    readonly service: RevealService;
    readonly connector: RevealApi;
    readonly scope: PartScope;
    readonly version: () => number;
}

export declare function wireEvents(node: Element, params: {
    events: Record<string, EventListener>;
    ref?: (node: Element | null) => void;
}): {
    update(next: typeof params): void;
    destroy(): void;
};

export interface RevealChangeDetail {
    readonly reason: RevealReason;
}

export declare const RevealContext: import("solid-js").Context<RevealContextValue | undefined>;

export interface RevealContextValue {
    readonly service: RevealService;
    readonly connector: RevealApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<RevealSnapshot>;
}

export declare function RevealRoot(props: RevealRootProps): JSX.Element;