@superxd-studio/adptr 0.5.0

package/types/reusable/interactions/agent.d.ts

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { InteractionStore, type JsonValue } from "./store.js";
+export declare const agentStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    tool: z.ZodString;
+    input: z.ZodCustom<JsonValue, JsonValue>;
+    scope: z.ZodString;
+}, z.core.$strict>;
+export type AgentStep = z.infer<typeof agentStepSchema>;
+export interface AgentRequest {
+    requestId: string;
+    step: AgentStep;
+    approvedUntil: number;
+}
+declare const resultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodLiteral<"completed">;
+    output: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodLiteral<"rejected">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodLiteral<"unknown">;
+}, z.core.$strict>], "status">;
+export type AgentResult = z.infer<typeof resultSchema>;
+export type AgentReceipt = AgentResult | {
+    requestId: string;
+    status: "pending" | "not-found";
+};
+export interface AgentAdapter {
+    /** Authorise on the server and deduplicate by requestId. Approval is only for this frozen step. */
+    execute(request: AgentRequest, signal: AbortSignal, progress: (message: string) => void): Promise<AgentResult>;
+    /** Look up the same receipt. not-found must mean definitely not accepted, not eventually invisible. */
+    lookup(requestId: string, signal: AbortSignal): Promise<AgentReceipt>;
+}
+export interface AgentSnapshot {
+    steps: readonly AgentStep[];
+    completed: readonly {
+        stepId: string;
+        requestId: string;
+        output: string;
+    }[];
+    phase: "ready" | "approval" | "running" | "checking" | "failed" | "uncertain" | "denied" | "expired" | "complete";
+    request?: AgentRequest;
+    progress?: string;
+    reason?: string;
+}
+type AgentEvent = {
+    type: "propose";
+    request: AgentRequest;
+} | {
+    type: "approve";
+} | {
+    type: "check";
+} | {
+    type: "progress";
+    message: string;
+} | {
+    type: "settle";
+    result: AgentResult;
+} | {
+    type: "uncertain";
+} | {
+    type: "deny";
+} | {
+    type: "expire";
+} | {
+    type: "revise";
+    steps: readonly AgentStep[];
+};
+export declare function agentReducer(state: AgentSnapshot, event: AgentEvent): AgentSnapshot;
+/** Supervises a finite plan. It never schedules work or invents a tool implementation. */
+export declare class AgentController extends InteractionStore<AgentSnapshot> {
+    private adapter;
+    private options;
+    private expiry?;
+    private ttl;
+    constructor(adapter: AgentAdapter, steps: readonly AgentStep[], options?: {
+        id?: () => string;
+        now?: () => number;
+        approvalMs?: number;
+    });
+    private now;
+    private send;
+    private propose;
+    revise(steps: readonly AgentStep[]): boolean;
+    next(): boolean;
+    approve(): boolean;
+    deny(): boolean;
+    stop(): boolean;
+    renew(): boolean;
+    check(): boolean;
+    dispose(): void;
+}
+export type { JsonValue };

package/types/reusable/interactions/artifact.d.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { InteractionStore } from "./store.js";
+export declare const artifactSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    revision: z.ZodString;
+    content: z.ZodString;
+    canEdit: z.ZodBoolean;
+    history: z.ZodArray<z.ZodObject<{
+        revision: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ArtifactRecord = z.infer<typeof artifactSchema>;
+export interface ArtifactRequest {
+    requestId: string;
+    artifactId: string;
+    baseRevision: string;
+    content: string;
+}
+declare const saveSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodLiteral<"saved">;
+    record: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        revision: z.ZodString;
+        content: z.ZodString;
+        canEdit: z.ZodBoolean;
+        history: z.ZodArray<z.ZodObject<{
+            revision: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodLiteral<"conflict">;
+    record: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        revision: z.ZodString;
+        content: z.ZodString;
+        canEdit: z.ZodBoolean;
+        history: z.ZodArray<z.ZodObject<{
+            revision: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodLiteral<"rejected">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodLiteral<"unknown">;
+}, z.core.$strict>], "status">;
+export type ArtifactResult = z.infer<typeof saveSchema>;
+export type ArtifactReceipt = ArtifactResult | {
+    requestId: string;
+    status: "pending" | "not-found";
+};
+export interface ArtifactAdapter {
+    load(id: string, signal: AbortSignal): Promise<ArtifactRecord>;
+    /** Use compare-and-swap on baseRevision, server permissions and a durable idempotent receipt. */
+    save(request: ArtifactRequest, signal: AbortSignal): Promise<ArtifactResult>;
+    lookup(requestId: string, signal: AbortSignal): Promise<ArtifactReceipt>;
+}
+export interface ArtifactSnapshot {
+    phase: "idle" | "loading" | "load-error" | "viewing" | "editing" | "saving" | "conflict" | "unknown" | "checking";
+    record?: ArtifactRecord;
+    draft: string;
+    latest?: ArtifactRecord;
+    request?: ArtifactRequest;
+    reason?: string;
+    loadId?: string;
+}
+type ArtifactEvent = {
+    type: "load";
+    id: string;
+} | {
+    type: "loaded";
+    record: ArtifactRecord;
+} | {
+    type: "load-error";
+} | {
+    type: "edit";
+    content: string;
+} | {
+    type: "save";
+    request: ArtifactRequest;
+} | {
+    type: "settle";
+    result: ArtifactResult;
+} | {
+    type: "unknown";
+} | {
+    type: "check";
+} | {
+    type: "not-found";
+} | {
+    type: "adopt";
+    keepDraft: boolean;
+};
+export declare function artifactReducer(state: ArtifactSnapshot, event: ArtifactEvent): ArtifactSnapshot;
+export declare class ArtifactController extends InteractionStore<ArtifactSnapshot> {
+    private adapter;
+    private id;
+    constructor(adapter: ArtifactAdapter, id?: () => string);
+    private send;
+    open(id: string): boolean;
+    edit(content: string): boolean;
+    discard(): boolean;
+    save(): boolean;
+    private validateResult;
+    adoptLatest(keepDraft: boolean): boolean;
+    check(): boolean;
+}
+export {};

package/types/reusable/interactions/context.d.ts

@@ -0,0 +1,130 @@
+import { type ReactNode } from "react";
+import { interactionCopy } from "./copy.js";
+type Widen<T> = T extends string ? string : T extends (...args: never[]) => unknown ? T : T extends object ? {
+    [K in keyof T]: Widen<T[K]>;
+} : T;
+export type InteractionCopy = Widen<typeof interactionCopy>;
+export type InteractionCopyOverrides = {
+    [K in keyof InteractionCopy]?: InteractionCopy[K] extends (...args: never[]) => unknown ? InteractionCopy[K] : InteractionCopy[K] extends object ? Partial<InteractionCopy[K]> : InteractionCopy[K];
+};
+/** Scope user-facing copy independently from state identities and server contracts. */
+export declare function InteractionProvider({ copy, children, }: {
+    copy?: InteractionCopyOverrides;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare const useInteractionCopy: () => {
+    readonly code: string;
+    readonly files: string;
+    readonly checks: string;
+    readonly passed: string;
+    readonly failed: string;
+    readonly artifactStates: {
+        readonly idle: string;
+        readonly loading: string;
+        readonly "load-error": string;
+        readonly viewing: string;
+        readonly editing: string;
+        readonly saving: string;
+        readonly conflict: string;
+        readonly unknown: string;
+        readonly checking: string;
+    };
+    readonly invalid: string;
+    readonly explanation: string;
+    readonly supplied: string;
+    readonly inputs: string;
+    readonly output: string;
+    readonly tool: string;
+    readonly sources: string;
+    readonly source: (index: number, title: string) => string;
+    readonly unavailable: string;
+    readonly noSources: string;
+    readonly retrieval: string;
+    readonly included: string;
+    readonly excluded: string;
+    readonly checkClaim: string;
+    readonly blocked: string;
+    readonly model: string;
+    readonly context: string;
+    readonly commands: string;
+    readonly quote: string;
+    readonly reply: string;
+    readonly connection: {
+        readonly connected: string;
+        readonly reconnecting: string;
+        readonly disconnected: string;
+    };
+    readonly disconnected: string;
+    readonly reconnect: string;
+    readonly trace: string;
+    readonly notReported: string;
+    readonly agent: string;
+    readonly plan: string;
+    readonly request: string;
+    readonly scope: string;
+    readonly allow: string;
+    readonly deny: string;
+    readonly stop: string;
+    readonly check: string;
+    readonly renew: string;
+    readonly unknown: string;
+    readonly approvalHint: string;
+    readonly expires: string;
+    readonly denied: string;
+    readonly complete: string;
+    readonly toolStates: {
+        readonly pending: string;
+        readonly approval: string;
+        readonly running: string;
+        readonly completed: string;
+        readonly rejected: string;
+        readonly unknown: string;
+    };
+    readonly agentStates: {
+        readonly ready: string;
+        readonly approval: string;
+        readonly running: string;
+        readonly checking: string;
+        readonly failed: string;
+        readonly uncertain: string;
+        readonly denied: string;
+        readonly expired: string;
+        readonly complete: string;
+    };
+    readonly artifact: string;
+    readonly edit: string;
+    readonly save: string;
+    readonly saving: string;
+    readonly discard: string;
+    readonly revision: string;
+    readonly artifactContent: string;
+    readonly latest: string;
+    readonly localDraft: string;
+    readonly conflict: string;
+    readonly useLatest: string;
+    readonly keepDraft: string;
+    readonly loadError: string;
+    readonly retry: string;
+    readonly idleArtifact: string;
+    readonly feedback: string;
+    readonly helpful: string;
+    readonly unhelpful: string;
+    readonly comment: string;
+    readonly sendFeedback: string;
+    readonly savedFeedback: string;
+    readonly failedFeedback: string;
+    readonly threads: string;
+    readonly refresh: string;
+    readonly active: string;
+    readonly archived: string;
+    readonly archive: string;
+    readonly restore: string;
+    readonly rename: string;
+    readonly title: string;
+    readonly saveTitle: string;
+    readonly chooseThread: string;
+    readonly noThreads: string;
+    readonly threadError: string;
+    readonly loading: string;
+};
+export {};

package/types/reusable/interactions/copy.d.ts

@@ -0,0 +1,115 @@
+export declare const interactionCopy: {
+    readonly code: "Code";
+    readonly files: "Files";
+    readonly checks: "Checks";
+    readonly passed: "Passed";
+    readonly failed: "Failed";
+    readonly artifactStates: {
+        readonly idle: "Choose an artifact";
+        readonly loading: "Loading artifact";
+        readonly "load-error": "Artifact unavailable";
+        readonly viewing: "Saved version";
+        readonly editing: "Draft edited";
+        readonly saving: "Saving revision";
+        readonly conflict: "Saved version changed";
+        readonly unknown: "Save result unknown";
+        readonly checking: "Checking save";
+    };
+    readonly invalid: "This content could not be displayed. Ask for an updated version.";
+    readonly explanation: "Progress explanation";
+    readonly supplied: "Reported by the host";
+    readonly inputs: "Inputs";
+    readonly output: "Result";
+    readonly tool: "Tool details";
+    readonly sources: "Sources";
+    readonly source: (index: number, title: string) => string;
+    readonly unavailable: "Source unavailable";
+    readonly noSources: "No sources were supplied.";
+    readonly retrieval: "Context used for this response";
+    readonly included: "Included";
+    readonly excluded: "Not included";
+    readonly checkClaim: "Check this claim";
+    readonly blocked: "This action cannot proceed";
+    readonly model: "Model";
+    readonly context: "Context to include";
+    readonly commands: "Commands";
+    readonly quote: "Quoted excerpt";
+    readonly reply: "Use excerpt in reply";
+    readonly connection: {
+        readonly connected: "Connected";
+        readonly reconnecting: "Reconnecting";
+        readonly disconnected: "Disconnected";
+    };
+    readonly disconnected: "The connection does not tell us whether remote work finished. Check the result before repeating an action.";
+    readonly reconnect: "Reconnect";
+    readonly trace: "Run measurements";
+    readonly notReported: "Not reported";
+    readonly agent: "Supervised plan";
+    readonly plan: "Proposed steps";
+    readonly request: "Review next step";
+    readonly scope: "Approval scope";
+    readonly allow: "Approve this step";
+    readonly deny: "Decline";
+    readonly stop: "Stop waiting";
+    readonly check: "Check status";
+    readonly renew: "Review again";
+    readonly unknown: "The result is unknown. Check the original request before running it again.";
+    readonly approvalHint: "Approval applies only to the displayed step and inputs. The host still checks your permissions.";
+    readonly expires: "Approval expires if you wait too long. Review the step again to continue.";
+    readonly denied: "The step was declined. Earlier completed work stays completed.";
+    readonly complete: "All steps are complete.";
+    readonly toolStates: {
+        readonly pending: "Pending";
+        readonly approval: "Awaiting approval";
+        readonly running: "Running";
+        readonly completed: "Complete";
+        readonly rejected: "Not applied";
+        readonly unknown: "Result unknown";
+    };
+    readonly agentStates: {
+        readonly ready: "Ready to review";
+        readonly approval: "Awaiting approval";
+        readonly running: "Working";
+        readonly checking: "Checking result";
+        readonly failed: "Step not applied";
+        readonly uncertain: "Result unknown";
+        readonly denied: "Declined";
+        readonly expired: "Approval expired";
+        readonly complete: "Complete";
+    };
+    readonly artifact: "Artifact";
+    readonly edit: "Edit draft";
+    readonly save: "Save revision";
+    readonly saving: "Saving revision";
+    readonly discard: "Discard edits";
+    readonly revision: "Revision";
+    readonly artifactContent: "Artifact content";
+    readonly latest: "Latest saved version";
+    readonly localDraft: "Your draft";
+    readonly conflict: "The saved version changed. Compare it with your draft before choosing what to keep.";
+    readonly useLatest: "Use latest saved version";
+    readonly keepDraft: "Keep my draft against the latest version";
+    readonly loadError: "Couldn’t load this artifact. Try again; the current work is still here.";
+    readonly retry: "Try again";
+    readonly idleArtifact: "Choose an artifact to open.";
+    readonly feedback: "Response feedback";
+    readonly helpful: "Helpful";
+    readonly unhelpful: "Needs work";
+    readonly comment: "What should change?";
+    readonly sendFeedback: "Save feedback";
+    readonly savedFeedback: "Feedback saved for this response.";
+    readonly failedFeedback: "Feedback is not confirmed. Retry with the same feedback.";
+    readonly threads: "Conversation history";
+    readonly refresh: "Refresh conversations";
+    readonly active: "Active";
+    readonly archived: "Archived";
+    readonly archive: "Archive conversation";
+    readonly restore: "Restore conversation";
+    readonly rename: "Rename conversation";
+    readonly title: "Conversation title";
+    readonly saveTitle: "Save title";
+    readonly chooseThread: "Choose a conversation to see its saved context.";
+    readonly noThreads: "No conversations in this view.";
+    readonly threadError: "Couldn’t complete that request. The current conversation is still here.";
+    readonly loading: "Loading";
+};

package/types/reusable/interactions/feedback.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { InteractionStore } from "./store.js";
+declare const feedbackSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    responseId: z.ZodString;
+    rating: z.ZodEnum<{
+        helpful: "helpful";
+        unhelpful: "unhelpful";
+    }>;
+    comment: z.ZodString;
+}, z.core.$strict>;
+export type FeedbackRequest = z.infer<typeof feedbackSchema>;
+export interface FeedbackAdapter {
+    /** Upsert feedback for responseId and deduplicate retries by requestId. Resolve only after storage acknowledges. */
+    save(request: FeedbackRequest, signal: AbortSignal): Promise<{
+        requestId: string;
+        responseId: string;
+    }>;
+}
+export interface FeedbackSnapshot {
+    responseId: string;
+    rating: "helpful" | "unhelpful" | null;
+    comment: string;
+    phase: "editing" | "saving" | "saved" | "error";
+    request?: FeedbackRequest;
+}
+export declare class FeedbackController extends InteractionStore<FeedbackSnapshot> {
+    private adapter;
+    private id;
+    constructor(adapter: FeedbackAdapter, responseId: string, id?: () => string);
+    edit(rating: FeedbackSnapshot["rating"], comment?: string): boolean;
+    save(): boolean;
+}
+export {};

package/types/reusable/interactions/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./agent.js";
+export * from "./artifact.js";
+export * from "./feedback.js";
+export * from "./threads.js";
+export * from "./presentation.js";
+export * from "./web.js";
+export { interactionCopy } from "./copy.js";
+export { jsonSchema } from "./store.js";
+export { InteractionProvider } from "./context.js";
+export type { InteractionCopy, InteractionCopyOverrides } from "./context.js";

package/types/reusable/interactions/presentation.d.ts

@@ -0,0 +1,97 @@
+import type { ReactNode } from "react";
+import { z } from "zod";
+import type { Choice, MenuCommand } from "../ui/index.js";
+import type { interactionCopy as copy } from "./copy.js";
+import { type JsonValue } from "./store.js";
+/** Evidence links may navigate only to explicit HTTP(S) destinations, without embedded credentials. */
+export declare function evidenceUrl(value: unknown): string | undefined;
+declare const sourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    excerpt: z.ZodOptional<z.ZodString>;
+    claim: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SourceDocument = z.infer<typeof sourceSchema>;
+export declare function Sources({ sources, label, }: {
+    sources: readonly SourceDocument[];
+    label?: string;
+}): import("react").JSX.Element;
+export declare function Citation({ source, index }: {
+    source: SourceDocument;
+    index: number;
+}): import("react").JSX.Element;
+export declare function RetrievalInspection({ documents, }: {
+    documents: readonly (SourceDocument & {
+        included: boolean;
+    })[];
+}): import("react").JSX.Element;
+export declare function Reasoning({ text, status, label, }: {
+    text: string;
+    status?: "working" | "complete";
+    label?: string;
+}): import("react").JSX.Element;
+export type ToolStatus = keyof typeof copy.toolStates;
+export declare function ToolCall({ title, status, input, output, }: {
+    title: string;
+    status: ToolStatus;
+    input: JsonValue;
+    output?: string;
+}): import("react").JSX.Element;
+export declare function Confidence({ claim, explanation }: {
+    claim: string;
+    explanation: string;
+}): import("react").JSX.Element;
+export declare function Guardrail({ reason, alternatives, onChoose, }: {
+    reason: string;
+    alternatives: readonly {
+        id: string;
+        label: string;
+    }[];
+    onChoose: (id: string) => void;
+}): import("react").JSX.Element;
+export declare function ConnectionStatus({ state, onReconnect, }: {
+    state: "connected" | "reconnecting" | "disconnected";
+    onReconnect?: () => void;
+}): import("react").JSX.Element;
+export declare function ComposerTools({ models, model, onModelChange, contexts, selectedContext, onContextChange, commands, onCommand, }: {
+    models: readonly Choice[];
+    model: string;
+    onModelChange: (id: string) => void;
+    contexts?: readonly Choice[];
+    selectedContext?: readonly string[];
+    onContextChange?: (ids: string[]) => void;
+    commands?: readonly MenuCommand[];
+    onCommand?: (id: string) => void;
+}): import("react").JSX.Element;
+export interface Quote {
+    text: string;
+    sourceId: string;
+    sourceTitle: string;
+}
+export declare function QuotedExcerpt({ quote, onReply, }: {
+    quote: Quote;
+    onReply?: (quote: Quote) => void;
+}): import("react").JSX.Element;
+export declare function ExecutionInspector({ code, files, output, tests, }: {
+    code?: string;
+    files?: readonly string[];
+    output?: string;
+    tests?: readonly {
+        name: string;
+        passed: boolean;
+    }[];
+}): import("react").JSX.Element;
+export declare function Observability({ measurements, }: {
+    measurements: readonly {
+        label: string;
+        value?: string | number;
+        unit?: string;
+    }[];
+}): import("react").JSX.Element;
+export declare function AgentStatus({ label, status, children, }: {
+    label: string;
+    status: string;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export {};

package/types/reusable/interactions/store.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export type JsonValue = string | number | boolean | null | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+export declare const jsonSchema: z.ZodCustom<JsonValue, JsonValue>;
+export declare const identity: z.ZodString;
+export declare const shortText: z.ZodString;
+export declare const bodyText: z.ZodString;
+export declare const newIdentity: () => `${string}-${string}-${string}-${string}-${string}`;
+/** Small external store shared by the concrete interaction owners. No execution is hidden here. */
+export declare class InteractionStore<S> {
+    protected state: S;
+    protected disposed: boolean;
+    protected generation: number;
+    protected abort?: AbortController;
+    private usedIds;
+    protected requestIdentity(create?: () => string): string;
+    private listeners;
+    constructor(initial: S);
+    getSnapshot: () => S;
+    subscribe: (listener: () => void) => () => boolean;
+    protected publish(state: S): void;
+    protected request(): {
+        token: number;
+        signal: AbortSignal;
+    };
+    protected current(token: number): boolean;
+    dispose(): void;
+}

package/types/reusable/interactions/threads.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { InteractionStore } from "./store.js";
+export declare const threadSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    archived: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const threadDocumentSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    archived: z.ZodBoolean;
+    payload: z.ZodCustom<import("./store.js").JsonValue, import("./store.js").JsonValue>;
+}, z.core.$strict>;
+export type ThreadSummary = z.infer<typeof threadSummarySchema>;
+export type ThreadDocument = z.infer<typeof threadDocumentSchema>;
+export interface ThreadAdapter {
+    list(signal: AbortSignal): Promise<readonly ThreadSummary[]>;
+    load(id: string, signal: AbortSignal): Promise<ThreadDocument>;
+    rename(id: string, title: string, signal: AbortSignal): Promise<ThreadSummary>;
+    archive(id: string, archived: boolean, signal: AbortSignal): Promise<ThreadSummary>;
+}
+export interface ThreadSnapshot {
+    phase: "idle" | "listing" | "opening" | "mutating" | "ready" | "error";
+    items: readonly ThreadSummary[];
+    selected?: ThreadDocument;
+    pendingId?: string;
+    operation?: "list" | "open" | "rename" | "archive";
+}
+export declare class ThreadController extends InteractionStore<ThreadSnapshot> {
+    private adapter;
+    private canLeave;
+    constructor(adapter: ThreadAdapter, canLeave?: () => boolean);
+    refresh(): boolean;
+    open(id: string): boolean;
+    rename(id: string, title: string): boolean;
+    archive(id: string, archived: boolean): boolean;
+    private mutate;
+}