@teaflask/assistant 0.0.0 → 0.6.0

package/dist/components/use-child-replay-stream.js

@@ -0,0 +1,186 @@
+"use client";
+import { useEffect, useId, useMemo, useRef, useState, useSyncExternalStore, } from "react";
+import { dispatchHasSettled, } from "../contract/dispatches.js";
+import { blockTimingRecorder, foldBlockTimingObserved, } from "../core/block-timing-anchors.js";
+import { messagesRecorder, streamErrorRecorder, } from "../core/messages-cell.js";
+import { TailSlotPool } from "../core/tail-slot-pool.js";
+import { toolCancelRecorder, withToolCancelAnchored, } from "../core/tool-cancel-anchors.js";
+import { toolErrorRecorder, withToolErrorAnchored, } from "../core/tool-error-anchors.js";
+import { ServingReplayStreamAgent } from "../transport/replay-stream-agent.js";
+import { streamUrlForChild } from "../transport/serving-api.js";
+import { resumeMarkerRecorder } from "../transport/stream-resume.js";
+const THREADLESS_ANCHORS = {
+    turnFailedAnchors: new Map(),
+    subagentDeliveryAnchors: new Map(),
+    toolCallDisplayAnchors: new Map(),
+    toolSchemaAnchors: new Map(),
+    toolOffloadAnchors: new Set(),
+    toolRefusalAnchors: new Map(),
+    toolDecisionAnchors: new Set(),
+    toolDenialAnchors: new Set(),
+    turnUsageAnchors: new Map(),
+    memoryProvenanceAnchors: new Map(),
+    memoryAttributionAnchors: new Map(),
+};
+const CHILD_TAIL_SLOTS = new TailSlotPool(1);
+export function useChildReplayStream({ session, threadId, childSessionId, refreshLedger, }) {
+    const [messages, setMessages] = useState([]);
+    const [streamEnd, setStreamEnd] = useState("open");
+    const [attempt, setAttempt] = useState(0);
+    const disposedRef = useRef(false);
+    useEffect(() => {
+        disposedRef.current = false;
+        return () => {
+            disposedRef.current = true;
+        };
+    }, []);
+    const [toolErrors, setToolErrors] = useState(() => new Map());
+    const [toolCancels, setToolCancels] = useState(() => new Set());
+    const [resumeAnchors, setResumeAnchors] = useState(() => new Map());
+    const [blockTimings, setBlockTimings] = useState(() => new Map());
+    const { tailed, slotDenied } = useChildTailLease(streamEnd);
+    useEffect(() => {
+        if (!tailed) {
+            return;
+        }
+        return openChildReplayStream({
+            session,
+            threadId,
+            childSessionId,
+            refreshLedger,
+            disposedRef,
+            setStreamEnd,
+            record: {
+                setMessages,
+                setToolErrors,
+                setToolCancels,
+                setResumeAnchors,
+                setBlockTimings,
+            },
+        });
+    }, [session, threadId, childSessionId, tailed, attempt, refreshLedger]);
+    const anchors = useMemo(() => ({
+        ...THREADLESS_ANCHORS,
+        resumeAnchors,
+        toolErrorAnchors: toolErrors,
+        toolCancelAnchors: toolCancels,
+        blockTimingAnchors: blockTimings,
+    }), [resumeAnchors, toolErrors, toolCancels, blockTimings]);
+    return {
+        messages,
+        streamEnd,
+        tailed,
+        slotDenied,
+        anchors,
+        retry: () => {
+            setStreamEnd("open");
+            setAttempt((known) => known + 1);
+        },
+    };
+}
+function useChildTailLease(streamEnd) {
+    const leaseId = useId();
+    useEffect(() => {
+        if (streamEnd !== "open") {
+            return;
+        }
+        CHILD_TAIL_SLOTS.acquire(leaseId);
+        return () => {
+            CHILD_TAIL_SLOTS.release(leaseId);
+        };
+    }, [leaseId, streamEnd]);
+    const tailed = useSyncExternalStore(CHILD_TAIL_SLOTS.subscribe, () => CHILD_TAIL_SLOTS.holds(leaseId), () => false);
+    const slotDenied = useSyncExternalStore(CHILD_TAIL_SLOTS.subscribe, () => CHILD_TAIL_SLOTS.waiting(leaseId), () => false);
+    return { tailed, slotDenied };
+}
+function openChildReplayStream({ session, threadId, childSessionId, refreshLedger, disposedRef, setStreamEnd, record, }) {
+    const agent = new ServingReplayStreamAgent({
+        streamUrl: streamUrlForChild(session, threadId, childSessionId),
+        streamThreadId: childSessionId,
+        authorizedFetch: session.authorizedFetch,
+    });
+    const unsubscribeAnchorTaps = subscribeAnchorTaps(agent, record);
+    let sawError = false;
+    const endWithError = () => {
+        if (sawError) {
+            return;
+        }
+        sawError = true;
+        void refreshLedger().finally(() => {
+            if (!disposedRef.current) {
+                setStreamEnd("error");
+            }
+        });
+    };
+    const errorTap = agent.subscribe(streamErrorRecorder(endWithError));
+    let sawTerminal = false;
+    let torn = false;
+    const terminalTap = agent.subscribe({
+        onRunFinishedEvent() {
+            sawTerminal = true;
+        },
+        onRunErrorEvent({ event }) {
+            if (event.code === "abort") {
+                return;
+            }
+            sawTerminal = true;
+            endWithError();
+        },
+    });
+    agent
+        .connectAgent()
+        .then(() => {
+        if (disposedRef.current || torn || sawError) {
+            return;
+        }
+        if (sawTerminal) {
+            void refreshLedger();
+            setStreamEnd("clean");
+            return;
+        }
+        void refreshLedger().then((row) => {
+            if (disposedRef.current || torn) {
+                return;
+            }
+            setStreamEnd(dispatchHasSettled(row) ? "clean" : "error");
+        });
+    })
+        .catch(() => undefined);
+    return () => {
+        torn = true;
+        unsubscribeAnchorTaps();
+        errorTap.unsubscribe();
+        terminalTap.unsubscribe();
+        agent.abortRun();
+        void agent.detachActiveRun().catch(() => undefined);
+    };
+}
+function subscribeAnchorTaps(agent, record) {
+    const messagesTap = agent.subscribe(messagesRecorder(record.setMessages));
+    const errorAnchorTap = agent.subscribe(toolErrorRecorder((toolCallId, errorText) => {
+        record.setToolErrors((previous) => withToolErrorAnchored(previous, toolCallId, errorText));
+    }));
+    const cancelAnchorTap = agent.subscribe(toolCancelRecorder((toolCallId) => {
+        record.setToolCancels((previous) => withToolCancelAnchored(previous, toolCallId));
+    }));
+    const resumeAnchorTap = agent.subscribe(resumeMarkerRecorder((_runId, messageId, markerValue) => {
+        record.setResumeAnchors((previous) => previous.has(messageId)
+            ? previous
+            : new Map(previous).set(messageId, markerValue));
+    }));
+    const timingAnchorTap = agent.subscribe(blockTimingRecorder((blockId, observedAtMs) => {
+        record.setBlockTimings((previous) => {
+            const next = new Map(previous);
+            return foldBlockTimingObserved(next, blockId, observedAtMs)
+                ? next
+                : previous;
+        });
+    }));
+    return () => {
+        messagesTap.unsubscribe();
+        errorAnchorTap.unsubscribe();
+        cancelAnchorTap.unsubscribe();
+        resumeAnchorTap.unsubscribe();
+        timingAnchorTap.unsubscribe();
+    };
+}

package/dist/components/use-latest-ref.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from "react";
+export declare function useLatestRef<T>(value: T): RefObject<T>;

package/dist/components/use-latest-ref.js

@@ -0,0 +1,9 @@
+"use client";
+import { useEffect, useRef } from "react";
+export function useLatestRef(value) {
+    const ref = useRef(value);
+    useEffect(() => {
+        ref.current = value;
+    });
+    return ref;
+}

package/dist/components/use-member-toggle-outrank.d.ts

@@ -0,0 +1,6 @@
+import { type MouseEvent, type RefObject } from "react";
+export declare function useMemberToggleOutrank(): {
+    groupRef: RefObject<HTMLDivElement | null>;
+    memberToggled: boolean;
+    onGroupActivation: (event: MouseEvent<HTMLDivElement>) => void;
+};

package/dist/components/use-member-toggle-outrank.js

@@ -0,0 +1,32 @@
+"use client";
+import { useEffect, useRef, useState, } from "react";
+export function useMemberToggleOutrank() {
+    const groupRef = useRef(null);
+    const [memberToggled, setMemberToggled] = useState(false);
+    const memberToggleIntentRef = useRef(false);
+    const onGroupActivation = (event) => {
+        const summary = event.target instanceof Element ? event.target.closest("summary") : null;
+        if (summary !== null &&
+            summary.parentElement ===
+                groupRef.current?.querySelector(":scope > details")) {
+            memberToggleIntentRef.current = true;
+        }
+    };
+    useEffect(() => {
+        const details = groupRef.current?.querySelector(":scope > details");
+        if (details === null || details === undefined) {
+            return;
+        }
+        const commitMemberToggle = () => {
+            if (memberToggleIntentRef.current) {
+                memberToggleIntentRef.current = false;
+                setMemberToggled(true);
+            }
+        };
+        details.addEventListener("toggle", commitMemberToggle);
+        return () => {
+            details.removeEventListener("toggle", commitMemberToggle);
+        };
+    }, []);
+    return { groupRef, memberToggled, onGroupActivation };
+}

package/dist/components/use-perch-clearance.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from "react";
+export declare function usePerchClearance(dockRef: RefObject<HTMLDivElement | null>, active: boolean): void;

package/dist/components/use-perch-clearance.js

@@ -0,0 +1,123 @@
+"use client";
+import { useEffect } from "react";
+import { firstClearLiftFor, INTERACTIVE_OBSTRUCTION_SELECTOR, } from "../core/perch-clearance.js";
+const LIFT_SETTLE_FALLBACK_MS = 400;
+function _shadowHostChainOf(node) {
+    const hosts = [];
+    let root = node.getRootNode();
+    while (root instanceof ShadowRoot) {
+        hosts.push(root.host);
+        root = root.host.getRootNode();
+    }
+    return hosts;
+}
+export function usePerchClearance(dockRef, active) {
+    useEffect(() => {
+        const dock = dockRef.current;
+        if (!active || dock === null) {
+            return;
+        }
+        return _watchPerchClearance(dock);
+    }, [dockRef, active]);
+}
+function _hostObstructionProbeFor(dock) {
+    const doc = dock.ownerDocument;
+    const shadowHostsOfDock = _shadowHostChainOf(dock);
+    return (point) => doc
+        .elementsFromPoint(point.x, point.y)
+        .some((element) => !dock.contains(element) &&
+        !shadowHostsOfDock.includes(element) &&
+        element.closest("[data-tf-assistant]") === null &&
+        element.closest(INTERACTIVE_OBSTRUCTION_SELECTOR) !== null);
+}
+function _hitBoxRectOf(dock, appliedLift) {
+    const body = dock.querySelector("[data-tf-companion-body]");
+    if (body === null) {
+        return null;
+    }
+    const rect = body.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) {
+        return null;
+    }
+    return {
+        left: rect.left,
+        top: rect.top + appliedLift,
+        width: rect.width,
+        height: rect.height,
+    };
+}
+function _watchPerchClearance(dock) {
+    const doc = dock.ownerDocument;
+    if (typeof doc.elementsFromPoint !== "function") {
+        return;
+    }
+    const view = doc.defaultView ?? window;
+    let frame = null;
+    let appliedLift = 0;
+    let settling = false;
+    let settleTimer = null;
+    const hostObstructionAt = _hostObstructionProbeFor(dock);
+    const measure = () => {
+        frame = null;
+        if (settling) {
+            return;
+        }
+        const rect = _hitBoxRectOf(dock, appliedLift);
+        if (rect === null) {
+            return;
+        }
+        const lift = firstClearLiftFor({ rect, probe: hostObstructionAt });
+        if (lift !== appliedLift) {
+            appliedLift = lift;
+            settling = true;
+            dock.style.setProperty("--_tf-companion-lift", `${String(lift)}px`);
+            settleTimer = view.setTimeout(settle, LIFT_SETTLE_FALLBACK_MS);
+        }
+    };
+    const scheduleMeasure = () => {
+        if (settling) {
+            return;
+        }
+        frame ??= view.requestAnimationFrame(measure);
+    };
+    const settle = () => {
+        if (!settling) {
+            return;
+        }
+        settling = false;
+        if (settleTimer !== null) {
+            view.clearTimeout(settleTimer);
+            settleTimer = null;
+        }
+        scheduleMeasure();
+    };
+    const settleOnBottomTransition = (event) => {
+        if (event.target === dock && event.propertyName === "bottom") {
+            settle();
+        }
+    };
+    scheduleMeasure();
+    view.addEventListener("resize", scheduleMeasure);
+    doc.addEventListener("scroll", scheduleMeasure, {
+        capture: true,
+        passive: true,
+    });
+    dock.addEventListener("transitionend", settleOnBottomTransition);
+    dock.addEventListener("transitioncancel", settleOnBottomTransition);
+    const observer = new MutationObserver(scheduleMeasure);
+    observer.observe(doc.body, { childList: true, subtree: true });
+    return () => {
+        if (frame !== null) {
+            view.cancelAnimationFrame(frame);
+        }
+        if (settleTimer !== null) {
+            view.clearTimeout(settleTimer);
+        }
+        view.removeEventListener("resize", scheduleMeasure);
+        doc.removeEventListener("scroll", scheduleMeasure, { capture: true });
+        dock.removeEventListener("transitionend", settleOnBottomTransition);
+        dock.removeEventListener("transitioncancel", settleOnBottomTransition);
+        observer.disconnect();
+        dock.style.removeProperty("--_tf-companion-lift");
+    };
+}

package/dist/components/use-question-panel-keys.d.ts

@@ -0,0 +1,32 @@
+import { type KeyboardEvent, type RefObject } from "react";
+import type { QuestionSetCardModel } from "../core/elicitation-cards.js";
+import type { QuestionModel } from "../core/elicitation-pickers.js";
+import { type QuestionAnswerDraft, type QuestionDraftStore } from "../core/question-drafts.js";
+import type { ElicitationSurface } from "./elicitation-context.js";
+type ActiveChoice = QuestionAnswerDraft["active"];
+interface QuestionPanelKeysInput {
+    card: QuestionSetCardModel;
+    drafts: QuestionDraftStore;
+    submitQuestionAnswers: ElicitationSurface["submitQuestionAnswers"];
+    cursor: number;
+    question: QuestionModel;
+    active: ActiveChoice;
+    customText: string;
+    answerable: boolean;
+    closeDescription: () => void;
+}
+interface ActiveChoiceWriters {
+    selectOption: (text: string) => void;
+    activateCustomIfDrafted: () => void;
+    setCustomText: (text: string) => void;
+}
+interface QuestionPanelKeys extends ActiveChoiceWriters {
+    rowsRef: RefObject<HTMLDivElement | null>;
+    customRef: RefObject<HTMLTextAreaElement | null>;
+    goTo: (next: number) => void;
+    proceed: () => void;
+    optionKeys: (index: number) => (event: KeyboardEvent<HTMLElement>) => void;
+    customKeys: (event: KeyboardEvent<HTMLTextAreaElement>) => void;
+}
+export declare function useQuestionPanelKeys(input: QuestionPanelKeysInput): QuestionPanelKeys;
+export {};

package/dist/components/use-question-panel-keys.js

@@ -0,0 +1,179 @@
+"use client";
+import { useEffect, useLayoutEffect, useRef, } from "react";
+import { answersOf, firstUnansweredIndexOf, MAX_ANSWER_TEXT_CHARS, overLimitOf, } from "../core/question-drafts.js";
+const CUSTOM_TEXTAREA_MAX_HEIGHT_PX = 192;
+export function useQuestionPanelKeys(input) {
+    const { card, drafts, cursor, active, customText, closeDescription } = input;
+    const rowsRef = useRef(null);
+    const customRef = useRef(null);
+    const focusAfterPageRef = useRef(false);
+    useEffect(() => {
+        if (!focusAfterPageRef.current) {
+            return;
+        }
+        focusAfterPageRef.current = false;
+        if (active?.kind === "custom") {
+            customRef.current?.focus();
+            return;
+        }
+        const rows = rowsRef.current?.querySelectorAll("[role=radio]");
+        if (rows === undefined || rows.length === 0) {
+            customRef.current?.focus();
+            return;
+        }
+        const checked = [...rows].find((row) => row.getAttribute("aria-checked") === "true");
+        (checked ?? rows[0]).focus();
+    }, [cursor, active]);
+    useLayoutEffect(() => {
+        const textarea = customRef.current;
+        if (textarea === null) {
+            return;
+        }
+        textarea.style.height = "auto";
+        if (textarea.scrollHeight === 0) {
+            return;
+        }
+        textarea.style.height = `${String(Math.min(textarea.scrollHeight, CUSTOM_TEXTAREA_MAX_HEIGHT_PX))}px`;
+    }, [customText, cursor]);
+    const goTo = (next) => {
+        if (next < 0 || next >= card.questions.length) {
+            return;
+        }
+        focusAfterPageRef.current = true;
+        closeDescription();
+        drafts.setCursor(card.interruptId, next);
+    };
+    const writers = activeChoiceWritersOf(input);
+    const focusRow = (index) => {
+        const rows = rowsRef.current?.querySelectorAll("[role=radio]");
+        if (rows === undefined) {
+            return;
+        }
+        if (index >= rows.length) {
+            writers.activateCustomIfDrafted();
+            customRef.current?.focus();
+            return;
+        }
+        rows[Math.max(index, 0)].focus();
+    };
+    const proceed = () => {
+        proceedFrom(input, goTo);
+    };
+    const gestures = {
+        question: input.question,
+        selectOption: writers.selectOption,
+        focusRow,
+        proceed,
+    };
+    return {
+        rowsRef,
+        customRef,
+        goTo,
+        proceed,
+        ...writers,
+        optionKeys: (index) => (event) => {
+            optionRowKey(gestures, index, event);
+        },
+        customKeys: (event) => {
+            customRowKey(gestures, event);
+        },
+    };
+}
+function proceedFrom(input, goTo) {
+    const { card, drafts, cursor, answerable, submitQuestionAnswers } = input;
+    if (cursor !== card.questions.length - 1) {
+        goTo(cursor + 1);
+        return;
+    }
+    const current = drafts.get(card.interruptId);
+    const over = overLimitOf(card.questions, current, MAX_ANSWER_TEXT_CHARS);
+    if (over.length > 0) {
+        const at = card.questions.findIndex((entry) => entry.id === over[0]);
+        if (at >= 0 && at !== cursor) {
+            goTo(at);
+        }
+        return;
+    }
+    const complete = answersOf(card.questions, current);
+    if (complete === null) {
+        const open = firstUnansweredIndexOf(card.questions, current);
+        if (open >= 0 && open !== cursor) {
+            goTo(open);
+        }
+        return;
+    }
+    if (!answerable) {
+        return;
+    }
+    void submitQuestionAnswers(card, complete);
+}
+function activeChoiceWritersOf(input) {
+    const { card, drafts, question, customText, answerable } = input;
+    const customIsDrafted = customText.trim() !== "";
+    return {
+        selectOption: (text) => {
+            if (!answerable) {
+                return;
+            }
+            drafts.selectOption(card.interruptId, question.id, text);
+        },
+        activateCustomIfDrafted: () => {
+            if (answerable && customIsDrafted) {
+                drafts.selectCustom(card.interruptId, question.id);
+            }
+        },
+        setCustomText: (text) => {
+            drafts.setCustomText(card.interruptId, question.id, text);
+        },
+    };
+}
+function optionRowKey({ question, selectOption, focusRow, proceed }, index, event) {
+    switch (event.key) {
+        case "ArrowDown":
+        case "ArrowRight": {
+            event.preventDefault();
+            const next = index + 1;
+            if (next < question.options.length) {
+                selectOption(question.options[next].text);
+            }
+            focusRow(next);
+            return;
+        }
+        case "ArrowUp":
+        case "ArrowLeft": {
+            event.preventDefault();
+            const previous = index - 1;
+            if (previous >= 0) {
+                selectOption(question.options[previous].text);
+                focusRow(previous);
+            }
+            return;
+        }
+        case " ":
+            event.preventDefault();
+            selectOption(question.options[index].text);
+            return;
+        case "Enter":
+            event.preventDefault();
+            selectOption(question.options[index].text);
+            proceed();
+            return;
+        default:
+            return;
+    }
+}
+function customRowKey({ question, selectOption, focusRow, proceed }, event) {
+    if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+        event.preventDefault();
+        proceed();
+        return;
+    }
+    if (event.key === "ArrowUp" &&
+        event.currentTarget.selectionStart === 0 &&
+        event.currentTarget.selectionEnd === 0 &&
+        question.options.length > 0) {
+        event.preventDefault();
+        selectOption(question.options[question.options.length - 1].text);
+        focusRow(question.options.length - 1);
+    }
+}

package/dist/components/use-register-assistant-surface.d.ts

@@ -0,0 +1,2 @@
+import { type AssistantSurfaceKind } from "../core/surface-registry.js";
+export declare function useRegisterAssistantSurface(kind: AssistantSurfaceKind, active?: boolean): void;

package/dist/components/use-register-assistant-surface.js

@@ -0,0 +1,11 @@
+"use client";
+import { useEffect } from "react";
+import { assistantSurfaceRegistry, } from "../core/surface-registry.js";
+export function useRegisterAssistantSurface(kind, active = true) {
+    useEffect(() => {
+        if (!active) {
+            return;
+        }
+        return assistantSurfaceRegistry.register(kind);
+    }, [kind, active]);
+}

package/dist/components/use-resolved-theme-mode.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from "react";
+import type { ToolViewThemeMode } from "../core/tool-view.js";
+export declare function useResolvedThemeMode(ref: RefObject<HTMLElement | null>): ToolViewThemeMode;

package/dist/components/use-resolved-theme-mode.js

@@ -0,0 +1,67 @@
+"use client";
+import { useEffect, useLayoutEffect, useState } from "react";
+const DARK_SCHEME_QUERY = "(prefers-color-scheme: dark)";
+export function useResolvedThemeMode(ref) {
+    const [mode, setMode] = useState("light");
+    useLayoutEffect(() => {
+        setMode(_resolvedThemeModeFor(ref.current));
+    }, [ref]);
+    useEffect(() => {
+        const resolve = () => {
+            setMode(_resolvedThemeModeFor(ref.current));
+        };
+        resolve();
+        const observer = new MutationObserver(resolve);
+        observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ["data-tf-theme"],
+            subtree: true,
+        });
+        const rootNode = ref.current?.getRootNode();
+        let shadowObserver = null;
+        if (rootNode instanceof ShadowRoot) {
+            shadowObserver = new MutationObserver(resolve);
+            shadowObserver.observe(rootNode, {
+                attributes: true,
+                attributeFilter: ["data-tf-theme"],
+                subtree: true,
+            });
+        }
+        if (typeof window.matchMedia !== "function") {
+            return () => {
+                observer.disconnect();
+                shadowObserver?.disconnect();
+            };
+        }
+        const media = window.matchMedia(DARK_SCHEME_QUERY);
+        media.addEventListener("change", resolve);
+        return () => {
+            observer.disconnect();
+            shadowObserver?.disconnect();
+            media.removeEventListener("change", resolve);
+        };
+    }, [ref]);
+    return mode;
+}
+function _resolvedThemeModeFor(element) {
+    if (element === null) {
+        return "light";
+    }
+    const root = element.closest("[data-tf-assistant]") ?? element;
+    const own = root.getAttribute("data-tf-theme");
+    if (own === "dark") {
+        return "dark";
+    }
+    if (own === "light") {
+        return "light";
+    }
+    if (own === "auto") {
+        return _prefersDark() ? "dark" : "light";
+    }
+    const ancestorDark = root.parentElement?.closest('[data-tf-theme="dark"]') ?? null;
+    return ancestorDark === null ? "light" : "dark";
+}
+function _prefersDark() {
+    return (typeof window.matchMedia === "function" &&
+        window.matchMedia(DARK_SCHEME_QUERY).matches);
+}

package/dist/components/use-roster-disclosure.d.ts

@@ -0,0 +1,20 @@
+import { type RefObject } from "react";
+interface RosterDisclosure {
+    open: boolean;
+    rosterId: string;
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    wrapperRef: RefObject<HTMLDivElement | null>;
+    onWrapperPointerEnter: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onWrapperPointerLeave: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onWrapperBlur: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onTriggerPointerDown: (event: React.PointerEvent<HTMLButtonElement>) => void;
+    onTriggerPointerCancel: () => void;
+    onTriggerFocus: () => void;
+    onTriggerClick: () => void;
+    onTriggerKeyDown: (event: React.KeyboardEvent<HTMLButtonElement>) => void;
+    close: () => void;
+    refocusTrigger: () => void;
+}
+export declare function useRosterDisclosure(): RosterDisclosure;
+export declare function useFloatingDismiss(floatingRef: RefObject<HTMLDivElement | null>, triggerRef: RefObject<HTMLButtonElement | null>, onClose: () => void): void;
+export {};