import { type TimelineSubscription } from "./connection/index.js";
import type { z } from "zod";
import { type ClientCapability } from "@getpaseo/protocol/client-capabilities";
import type { AgentAttentionNotificationPayload } from "@getpaseo/protocol/agent-attention-notification";
import { AgentRefreshedStatusPayloadSchema, CheckoutRenameBranchResponseSchema, RenameTerminalResponseSchema, RestartRequestedStatusPayloadSchema, ShutdownRequestedStatusPayloadSchema, DaemonUpdateResponseSchema, type ActiveTurnBehavior, type ServerInfoStatusPayload } from "@getpaseo/protocol/messages";
import type { AgentStreamEventPayload, AgentSnapshotPayload, ProjectPlacementPayload, AgentPermissionResolvedMessage, CreateAgentRequestMessage, CreatePaseoWorktreeRequest, FileDownloadTokenResponse, FileUploadResponse, FileExplorerResponse, FileVersion, FileWriteResult, FetchAgentTimelineResponseMessage, AgentForkContextResponseMessage, GitSetupOptions, CheckoutStatusResponse, CheckoutCommit, ParsedDiffFile, CheckoutCommitResponse, CheckoutMergeResponse, CheckoutMergeFromBaseResponse, CheckoutPullResponse, CheckoutPushResponse, CheckoutRefreshResponse, CheckoutPrCreateResponse, CheckoutPrMergeResponse, CheckoutPrMergeMethod, CheckoutForgeSetAutoMergeResponse, CheckoutGithubSetAutoMergeResponse, CheckoutForgeGetCheckDetailsResponse, CheckoutGithubGetCheckDetailsResponse, CheckoutPrStatusResponse, PullRequestTimelineResponse, CheckoutSwitchBranchResponse, StashSaveResponse, StashPopResponse, StashListResponse, ValidateBranchResponse, BranchSuggestionsResponse, ForgeSearchResponse, ForgeSearchRequest, GitHubSearchResponse, GitHubSearchRequest, DirectorySuggestionsResponse, PaseoWorktreeListResponse, PaseoWorktreeArchiveResponse, ProjectIconSource, ProjectIconResponse, ProjectIconGetResponse, ProjectAddResponse, ProjectCreateDirectoryResponse, OpenProjectResponseMessage, WorkspaceGithubSearchRepositoriesResponse, ProjectGithubCloneProtocol, ProjectGithubCloneResponse, ArchiveWorkspaceResponseMessage, WorkspaceSetupStatusResponseMessage, ListCommandsResponse, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ListProviderModesResponseMessage, ListAvailableProvidersResponse, GetProvidersSnapshotResponseMessage, RefreshProvidersSnapshotResponseMessage, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, DaemonGetStatusResponse, DaemonGetPairingOfferResponse, DaemonConfigReloadResponse, DiagnosticsResponse, AgentRewindResponseMessage, ListTerminalsResponse, CreateTerminalResponse, SubscribeTerminalResponse, SubscribeTerminalRequest, CloseItemsResponse, KillTerminalResponse, CaptureTerminalResponse, TerminalInput, SessionInboundMessage, SessionOutboundMessage, SendAgentMessageRequest, PaseoConfigRaw, PaseoConfigRevision, WorkspaceCreateRequest, WorkspaceRecoveryState, PluginListItem, PluginLogEntry, PluginSourceStatusItem, PluginSourceUpdateItem, AgentSkillSelection, AgentSkillsStatus, AgentSkillsSaveResult } from "@getpaseo/protocol/messages";
import type { AgentPermissionRequest, AgentPermissionResponse, AgentPersistenceHandle, AgentProviderNotice, AgentProvider, AgentSessionConfig } from "@getpaseo/protocol/agent-types";
import type { AgentConfigApply, MutableDaemonConfig, MutableDaemonConfigPatch } from "@getpaseo/protocol/messages";
import { type DaemonTransportFactory, type WebSocketFactory } from "./daemon-client-transport.js";
import { type TerminalStreamEvent } from "./terminal-stream-router.js";
import type { BrowserAutomationExecuteRequest, BrowserAutomationExecuteResponse } from "@getpaseo/protocol/browser-automation/rpc-schemas";
export interface Logger {
    debug(obj: object, msg?: string): void;
    info(obj: object, msg?: string): void;
    warn(obj: object, msg?: string): void;
    error(obj: object, msg?: string): void;
}
interface ImportAgentInputBase {
    cwd?: string;
    workspaceId?: string;
    labels?: Record<string, string>;
}
export type ImportAgentInput = (ImportAgentInputBase & {
    providerId: string;
    providerHandleId: string;
}) | (ImportAgentInputBase & {
    provider: AgentProvider;
    sessionId: string;
});
export type { DaemonTransport, DaemonTransportFactory, WebSocketFactory, WebSocketLike, } from "./daemon-client-transport.js";
export type { TerminalStreamEvent };
export type ConnectionState = {
    status: "idle";
} | {
    status: "connecting";
    attempt: number;
} | {
    status: "connected";
} | {
    status: "disconnected";
    reason?: string;
} | {
    status: "disposed";
};
export type DaemonEvent = {
    type: "agent_update";
    agentId: string;
    payload: Extract<SessionOutboundMessage, {
        type: "agent_update";
    }>["payload"];
} | {
    type: "workspace_update";
    workspaceId: string;
    payload: Extract<SessionOutboundMessage, {
        type: "workspace_update";
    }>["payload"];
} | {
    type: "project.update";
    payload: Extract<SessionOutboundMessage, {
        type: "project.update";
    }>["payload"];
} | {
    type: "workspace_setup_progress";
    workspaceId: string;
    payload: Extract<SessionOutboundMessage, {
        type: "workspace_setup_progress";
    }>["payload"];
} | {
    type: "agent_stream";
    agentId: string;
    event: AgentStreamEventPayload;
    timestamp: string;
    seq?: number;
    epoch?: string;
} | {
    type: "status";
    payload: {
        status: string;
    } & Record<string, unknown>;
} | {
    type: "agent_deleted";
    agentId: string;
} | {
    type: "agent_permission_request";
    agentId: string;
    request: AgentPermissionRequest;
} | {
    type: "agent_permission_resolved";
    agentId: string;
    requestId: string;
    resolution: AgentPermissionResponse;
} | {
    type: "providers_snapshot_update";
    payload: Extract<SessionOutboundMessage, {
        type: "providers_snapshot_update";
    }>["payload"];
} | {
    type: "error";
    message: string;
};
export type DaemonEventHandler = (event: DaemonEvent) => void;
export type BrowserAutomationExecuteRequestMessage = BrowserAutomationExecuteRequest;
export type BrowserAutomationExecuteResponseMessage = BrowserAutomationExecuteResponse;
export interface DaemonClientConfig {
    /** Deliver compact bodies/hash references to a caller-owned snapshot cache.
     * The default keeps public SDK snapshot entries expanded. */
    providerSnapshots?: "wire";
    url: string;
    clientId: string;
    clientType?: "mobile" | "browser" | "cli" | "mcp" | "hub";
    appVersion?: string;
    runtimeGeneration?: number | null;
    password?: string;
    authHeader?: string;
    suppressSendErrors?: boolean;
    transportFactory?: DaemonTransportFactory;
    webSocketFactory?: WebSocketFactory;
    logger?: Logger;
    connectTimeoutMs?: number;
    e2ee?: {
        enabled?: boolean;
        daemonPublicKeyB64?: string;
    };
    reconnect?: {
        enabled?: boolean;
        baseDelayMs?: number;
        maxDelayMs?: number;
    };
    runtimeMetricsIntervalMs?: number;
    runtimeMetricsWindowMs?: number;
    trace?: DaemonClientTrace;
    capabilities?: Partial<Record<ClientCapability, unknown>>;
}
export interface DaemonClientTrace {
    isEnabled(): boolean;
    beginSection(name: string, args?: Record<string, string>): void;
    endSection(): void;
}
export interface SendMessageOptions {
    messageId?: string;
    activeTurnBehavior?: ActiveTurnBehavior;
    images?: Array<{
        data: string;
        mimeType: string;
    }>;
    attachments?: SendAgentMessageRequest["attachments"];
}
export interface AgentAttentionRequiredNotification {
    agentId: string;
    reason: "finished" | "error" | "permission";
    timestamp: string;
    shouldNotify: boolean;
    notification?: AgentAttentionNotificationPayload;
}
type AgentConfigOverrides = Partial<Omit<AgentSessionConfig, "provider" | "cwd">>;
export interface CreateAgentRequestOptions extends AgentConfigOverrides {
    config?: AgentSessionConfig;
    provider?: AgentProvider;
    cwd?: string;
    env?: CreateAgentRequestMessage["env"];
    workspaceId?: string;
    callerAgentId?: string;
    initialPrompt?: string;
    idempotencyKey?: string;
    clientMessageId?: string;
    outputSchema?: Record<string, unknown>;
    images?: CreateAgentRequestMessage["images"];
    attachments?: CreateAgentRequestMessage["attachments"];
    git?: GitSetupOptions;
    worktree?: CreateAgentRequestMessage["worktree"];
    autoArchive?: CreateAgentRequestMessage["autoArchive"];
    worktreeName?: string;
    requestId?: string;
    labels?: Record<string, string>;
}
export interface CreatePaseoWorktreeInput extends Pick<CreatePaseoWorktreeRequest, "cwd" | "projectId" | "worktreeSlug" | "firstAgentContext" | "refName" | "action" | "checkoutSource" | "githubPrNumber"> {
}
type CheckoutStatusPayload = CheckoutStatusResponse["payload"];
type SubscribeCheckoutDiffPayload = Extract<SessionOutboundMessage, {
    type: "subscribe_checkout_diff_response";
}>["payload"];
type CheckoutDiffPayload = Omit<SubscribeCheckoutDiffPayload, "subscriptionId">;
type CheckoutCommitPayload = CheckoutCommitResponse["payload"];
type CheckoutMergePayload = CheckoutMergeResponse["payload"];
type CheckoutMergeFromBasePayload = CheckoutMergeFromBaseResponse["payload"];
type CheckoutPullPayload = CheckoutPullResponse["payload"];
type CheckoutPushPayload = CheckoutPushResponse["payload"];
type CheckoutRefreshPayload = CheckoutRefreshResponse["payload"];
type CheckoutPrCreatePayload = CheckoutPrCreateResponse["payload"];
type CheckoutPrMergePayload = CheckoutPrMergeResponse["payload"];
type CheckoutForgeSetAutoMergePayload = CheckoutForgeSetAutoMergeResponse["payload"];
type CheckoutGithubSetAutoMergePayload = CheckoutGithubSetAutoMergeResponse["payload"];
type CheckoutForgeGetCheckDetailsPayload = CheckoutForgeGetCheckDetailsResponse["payload"];
type CheckoutGithubGetCheckDetailsPayload = CheckoutGithubGetCheckDetailsResponse["payload"];
type CheckoutPrStatusPayload = CheckoutPrStatusResponse["payload"];
type PullRequestTimelinePayload = PullRequestTimelineResponse["payload"];
type CheckoutSwitchBranchPayload = CheckoutSwitchBranchResponse["payload"];
export type RenameBranchResult = z.infer<typeof CheckoutRenameBranchResponseSchema>["payload"];
type StashSavePayload = StashSaveResponse["payload"];
type StashPopPayload = StashPopResponse["payload"];
type StashListPayload = StashListResponse["payload"];
type ValidateBranchPayload = ValidateBranchResponse["payload"];
type BranchSuggestionsPayload = BranchSuggestionsResponse["payload"];
type ForgeSearchPayload = ForgeSearchResponse["payload"];
type GitHubSearchPayload = GitHubSearchResponse["payload"];
type DirectorySuggestionsPayload = DirectorySuggestionsResponse["payload"];
type PaseoWorktreeListPayload = PaseoWorktreeListResponse["payload"];
type PaseoWorktreeArchivePayload = PaseoWorktreeArchiveResponse["payload"];
type CreatePaseoWorktreePayload = Extract<SessionOutboundMessage, {
    type: "create_paseo_worktree_response";
}>["payload"];
type WorkspaceCreatePayload = Extract<SessionOutboundMessage, {
    type: "workspace.create.response";
}>["payload"];
type FileExplorerPayload = FileExplorerResponse["payload"];
export type FileExplorerDirectoryPayload = NonNullable<FileExplorerPayload["directory"]>;
type LegacyFileExplorerFilePayload = NonNullable<FileExplorerPayload["file"]>;
export interface FileReadResult {
    bytes: Uint8Array;
    mime: string;
    size: number;
    path: string;
    kind: LegacyFileExplorerFilePayload["kind"];
    modifiedAt: string;
    revision?: string;
}
export interface FileUploadInput {
    fileName: string;
    mimeType: string;
    bytes: Uint8Array | ArrayBuffer;
    modifiedAt?: string;
    requestId?: string;
    chunkSize?: number;
}
export type FileUploadResult = FileUploadResponse["payload"];
type FileDownloadTokenPayload = FileDownloadTokenResponse["payload"];
type ListProviderFeaturesPayload = ListProviderFeaturesResponseMessage["payload"];
type ListProviderModelsPayload = ListProviderModelsResponseMessage["payload"];
type ListProviderModesPayload = ListProviderModesResponseMessage["payload"];
type ListAvailableProvidersPayload = ListAvailableProvidersResponse["payload"];
type GetProvidersSnapshotPayload = GetProvidersSnapshotResponseMessage["payload"];
type RefreshProvidersSnapshotPayload = RefreshProvidersSnapshotResponseMessage["payload"];
type ProviderDiagnosticPayload = ProviderDiagnosticResponseMessage["payload"];
type ProviderUsageListPayload = ProviderUsageListResponseMessage["payload"];
type DaemonStatusPayload = DaemonGetStatusResponse["payload"];
type DaemonPairingOfferPayload = DaemonGetPairingOfferResponse["payload"];
type DiagnosticsPayload = DiagnosticsResponse["payload"];
type ReadProjectConfigPayload = Extract<SessionOutboundMessage, {
    type: "read_project_config_response";
}>["payload"];
type WriteProjectConfigPayload = Extract<SessionOutboundMessage, {
    type: "write_project_config_response";
}>["payload"];
type ListCommandsPayload = ListCommandsResponse["payload"];
type ListCommandsDraftConfig = Pick<AgentSessionConfig, "provider" | "cwd" | "modeId" | "model" | "thinkingOptionId" | "featureValues">;
export interface WriteProjectConfigInput {
    repoRoot: string;
    config: PaseoConfigRaw;
    expectedRevision: PaseoConfigRevision | null;
    requestId?: string;
}
interface ListCommandsOptions {
    agentId: string;
    requestId?: string;
    draftConfig?: ListCommandsDraftConfig;
}
type LegacyListCommandsOptions = Omit<ListCommandsOptions, "agentId">;
type SetVoiceModePayload = Extract<SessionOutboundMessage, {
    type: "set_voice_mode_response";
}>["payload"];
type AgentPermissionResolvedPayload = AgentPermissionResolvedMessage["payload"];
type ListTerminalsPayload = ListTerminalsResponse["payload"];
type CreateTerminalPayload = CreateTerminalResponse["payload"];
export type RenameTerminalResult = z.infer<typeof RenameTerminalResponseSchema>["payload"];
type SubscribeTerminalPayload = SubscribeTerminalResponse["payload"];
type CloseItemsPayload = CloseItemsResponse["payload"];
type KillTerminalPayload = KillTerminalResponse["payload"];
type CaptureTerminalPayload = CaptureTerminalResponse["payload"];
type ScheduleCreatePayload = Extract<SessionOutboundMessage, {
    type: "schedule/create/response";
}>["payload"];
type ScheduleListPayload = Extract<SessionOutboundMessage, {
    type: "schedule/list/response";
}>["payload"];
type ScheduleInspectPayload = Extract<SessionOutboundMessage, {
    type: "schedule/inspect/response";
}>["payload"];
type ScheduleLogsPayload = Extract<SessionOutboundMessage, {
    type: "schedule/logs/response";
}>["payload"];
type SchedulePausePayload = Extract<SessionOutboundMessage, {
    type: "schedule/pause/response";
}>["payload"];
type ScheduleResumePayload = Extract<SessionOutboundMessage, {
    type: "schedule/resume/response";
}>["payload"];
type ScheduleDeletePayload = Extract<SessionOutboundMessage, {
    type: "schedule/delete/response";
}>["payload"];
type ScheduleRunOncePayload = Extract<SessionOutboundMessage, {
    type: "schedule/run-once/response";
}>["payload"];
type ScheduleUpdatePayload = Extract<SessionOutboundMessage, {
    type: "schedule/update/response";
}>["payload"];
export type FetchAgentTimelinePayload = FetchAgentTimelineResponseMessage["payload"];
export type AgentForkContextPayload = AgentForkContextResponseMessage["payload"];
export type FetchAgentTimelineDirection = FetchAgentTimelinePayload["direction"];
export type FetchAgentTimelineProjection = FetchAgentTimelinePayload["projection"];
export type FetchAgentTimelineCursor = NonNullable<FetchAgentTimelinePayload["startCursor"]>;
export interface FetchAgentOptions {
    agentId: string;
    requestId?: string;
    timeout?: number;
}
type LegacyFetchAgentOptions = Omit<FetchAgentOptions, "agentId">;
export interface FetchAgentTimelineOptions {
    direction?: FetchAgentTimelineDirection;
    cursor?: FetchAgentTimelineCursor;
    limit?: number;
    projection?: FetchAgentTimelineProjection;
    mergeWindow?: boolean;
    requestId?: string;
    timeout?: number;
}
export type AgentTimelinePromptIndexPayload = Extract<SessionOutboundMessage, {
    type: "agent.timeline.list_prompts.response";
}>["payload"];
export type ProviderSubagentListPayload = Extract<SessionOutboundMessage, {
    type: "agent.provider_subagents.list.response";
}>["payload"];
export type ProviderSubagentTimelinePayload = Extract<SessionOutboundMessage, {
    type: "agent.provider_subagents.timeline.get.response";
}>["payload"];
export interface FetchProviderSubagentTimelineOptions {
    direction?: ProviderSubagentTimelinePayload["direction"];
    cursor?: FetchAgentTimelineCursor;
    limit?: number;
    requestId?: string;
    timeout?: number;
}
export interface AgentForkContextOptions {
    boundaryCursor?: FetchAgentTimelineCursor;
    boundaryMessageId?: string;
    requestId?: string;
}
type AgentRefreshedStatusPayload = z.infer<typeof AgentRefreshedStatusPayloadSchema>;
type RestartRequestedStatusPayload = z.infer<typeof RestartRequestedStatusPayloadSchema>;
type ShutdownRequestedStatusPayload = z.infer<typeof ShutdownRequestedStatusPayloadSchema>;
export interface ShutdownServerOptions {
    requestId?: string;
    timeout?: number;
}
export interface DaemonStatusOptions {
    requestId?: string;
    timeout?: number;
}
export interface DaemonPairingOfferOptions {
    requestId?: string;
    timeout?: number;
}
type DaemonUpdateResponse = z.infer<typeof DaemonUpdateResponseSchema>;
type FetchAgentsPayload = Extract<SessionOutboundMessage, {
    type: "fetch_agents_response";
}>["payload"];
type FetchAgentsRequest = Extract<SessionInboundMessage, {
    type: "fetch_agents_request";
}>;
export type FetchAgentsOptions = Omit<FetchAgentsRequest, "type" | "requestId"> & {
    requestId?: string;
    timeout?: number;
};
export type FetchAgentsEntry = FetchAgentsPayload["entries"][number];
export type FetchAgentsPageInfo = FetchAgentsPayload["pageInfo"];
type FetchAgentHistoryPayload = Extract<SessionOutboundMessage, {
    type: "fetch_agent_history_response";
}>["payload"];
type FetchAgentHistoryRequest = Extract<SessionInboundMessage, {
    type: "fetch_agent_history_request";
}>;
export type FetchAgentHistoryOptions = Omit<FetchAgentHistoryRequest, "type" | "requestId"> & {
    requestId?: string;
};
export type FetchAgentHistoryEntry = FetchAgentHistoryPayload["entries"][number];
export type FetchAgentHistoryPageInfo = FetchAgentHistoryPayload["pageInfo"];
type FetchRecentProviderSessionsPayload = Extract<SessionOutboundMessage, {
    type: "fetch_recent_provider_sessions_response";
}>["payload"];
type FetchRecentProviderSessionsRequest = Extract<SessionInboundMessage, {
    type: "fetch_recent_provider_sessions_request";
}>;
export type FetchRecentProviderSessionsOptions = Omit<FetchRecentProviderSessionsRequest, "type" | "requestId"> & {
    requestId?: string;
};
export type FetchRecentProviderSessionEntry = FetchRecentProviderSessionsPayload["entries"][number];
type FetchWorkspacesPayload = Extract<SessionOutboundMessage, {
    type: "fetch_workspaces_response";
}>["payload"];
type FetchWorkspacesRequest = Extract<SessionInboundMessage, {
    type: "fetch_workspaces_request";
}>;
export type FetchWorkspacesOptions = Omit<FetchWorkspacesRequest, "type" | "requestId"> & {
    requestId?: string;
};
export type FetchWorkspacesEntry = FetchWorkspacesPayload["entries"][number];
export type FetchWorkspacesPageInfo = FetchWorkspacesPayload["pageInfo"];
export type WorkspaceLabelListPayload = Extract<SessionOutboundMessage, {
    type: "workspace.label.list.response";
}>["payload"];
export type WorkspaceLabelAssignmentPayload = Extract<SessionOutboundMessage, {
    type: "workspace.label.assignment.set.response";
}>["payload"];
export type WorkspaceLabelUpdatePayload = Extract<SessionOutboundMessage, {
    type: "workspace.label.update.response";
}>["payload"];
export type WorkspaceLabelDeletePayload = Extract<SessionOutboundMessage, {
    type: "workspace.label.delete.response";
}>["payload"];
export type WorkspaceLabelDeleteInspectPayload = Extract<SessionOutboundMessage, {
    type: "workspace.label.delete.inspect.response";
}>["payload"];
export type ProjectListPayload = Extract<SessionOutboundMessage, {
    type: "project.list.response";
}>["payload"];
type ProjectListRequest = Extract<SessionInboundMessage, {
    type: "project.list.request";
}>;
export type ProjectListOptions = Omit<ProjectListRequest, "type" | "requestId"> & {
    requestId?: string;
};
export interface CreateScheduleOptions {
    prompt: string;
    name?: string | null;
    cadence: {
        type: "cron";
        expression: string;
        timezone?: string;
    };
    target: {
        type: "self";
        agentId: string;
    } | {
        type: "agent";
        agentId: string;
    } | {
        type: "new-agent";
        config: {
            provider: AgentProvider;
            cwd: string;
            modeId?: string;
            model?: string;
            thinkingOptionId?: string;
            archiveOnFinish?: boolean;
            isolation?: "local" | "worktree";
            title?: string | null;
            providerOptions?: AgentSessionConfig["providerOptions"];
            systemPrompt?: string;
            mcpServers?: AgentSessionConfig["mcpServers"];
        };
    };
    maxRuns?: number;
    expiresAt?: string;
    runOnCreate?: boolean;
    requestId?: string;
}
export interface InspectScheduleOptions {
    id: string;
    requestId?: string;
}
export interface UpdateScheduleNewAgentConfig {
    provider?: string;
    model?: string | null;
    modeId?: string | null;
    thinkingOptionId?: string | null;
    archiveOnFinish?: boolean;
    isolation?: "local" | "worktree";
    cwd?: string;
}
export interface UpdateScheduleOptions {
    id: string;
    name?: string | null;
    prompt?: string;
    cadence?: {
        type: "cron";
        expression: string;
        timezone?: string;
    };
    newAgentConfig?: UpdateScheduleNewAgentConfig;
    maxRuns?: number | null;
    expiresAt?: string | null;
    requestId?: string;
}
export interface RenameBranchInput {
    cwd: string;
    branch: string;
    requestId?: string;
}
export interface RenameTerminalInput {
    terminalId: string;
    title: string;
    requestId?: string;
}
type OpenProjectPayload = OpenProjectResponseMessage["payload"];
type ProjectAddPayload = ProjectAddResponse["payload"];
export type ProjectCreateDirectoryPayload = ProjectCreateDirectoryResponse["payload"];
export type WorkspaceGithubSearchRepositoriesPayload = WorkspaceGithubSearchRepositoriesResponse["payload"];
type ProjectGithubClonePayload = ProjectGithubCloneResponse["payload"];
type ArchiveWorkspacePayload = ArchiveWorkspaceResponseMessage["payload"];
type WorkspaceSetupStatusPayload = WorkspaceSetupStatusResponseMessage["payload"];
export interface FetchAgentResult {
    agent: AgentSnapshotPayload;
    project: ProjectPlacementPayload | null;
}
export interface WaitForFinishResult {
    status: "idle" | "error" | "permission" | "timeout";
    final: AgentSnapshotPayload | null;
    error: string | null;
    lastMessage: string | null;
}
type GetDaemonConfigResponse = Extract<SessionOutboundMessage, {
    type: "get_daemon_config_response";
}>;
type SetDaemonConfigResponse = Extract<SessionOutboundMessage, {
    type: "set_daemon_config_response";
}>;
type CorrelatedResponseMessage = Extract<SessionOutboundMessage, {
    payload: {
        requestId: string;
    };
}> | GetDaemonConfigResponse | SetDaemonConfigResponse;
type CorrelatedResponseType = CorrelatedResponseMessage["type"];
type CorrelatedResponsePayload<TType extends CorrelatedResponseType> = Extract<CorrelatedResponseMessage, {
    type: TType;
}>["payload"];
export declare class DaemonClient {
    private config;
    private readonly providerSnapshotUpdates;
    private readonly subscriptions;
    private transport;
    private transportCleanup;
    private rawMessageListeners;
    private messageHandlers;
    private eventListeners;
    private waiters;
    private checkoutStatusInFlight;
    private connectionListeners;
    private reconnectTimeout;
    private connectTimeout;
    private pendingGenericTransportErrorTimeout;
    private reconnectAttempt;
    private shouldReconnect;
    private connectPromise;
    private connectResolve;
    private connectReject;
    private lastErrorValue;
    private connectionState;
    private checkoutDiffSubscriptions;
    private terminalDirectorySubscriptions;
    private fileSubscriptions;
    private readonly terminalStreams;
    private pendingBinaryFileReads;
    private activeBinaryFileTransfers;
    private completedBinaryFileReads;
    private logger;
    private pendingSendQueue;
    private readonly logConnectionPath;
    private readonly logServerId;
    private readonly logClientIdHash;
    private readonly logGeneration;
    private lastServerInfoMessage;
    private runtimeMetricsInterval;
    private runtimeMetrics;
    private pingProbe;
    private livenessHeartbeatTimer;
    private lastLivenessRttMs;
    private consecutiveLivenessFailures;
    constructor(config: DaemonClientConfig);
    connect(): Promise<void>;
    private attemptConnect;
    private resolveConnect;
    private rejectConnect;
    close(): Promise<void>;
    ensureConnected(): void;
    getConnectionState(): ConnectionState;
    subscribeConnectionStatus(listener: (status: ConnectionState) => void): () => void;
    get isConnected(): boolean;
    get isConnecting(): boolean;
    get lastError(): string | null;
    getLastLivenessRttMs(): number | null;
    subscribe(handler: DaemonEventHandler): () => void;
    subscribeRawMessages(handler: (message: SessionOutboundMessage) => void): () => void;
    on<TType extends SessionOutboundMessage["type"]>(type: TType, handler: (message: Extract<SessionOutboundMessage, {
        type: TType;
    }>) => void): () => void;
    on(handler: DaemonEventHandler): () => void;
    onAgentAttentionRequired(handler: (notification: AgentAttentionRequiredNotification) => void): () => void;
    private beginTraceSection;
    private endTraceSection;
    private traceInstant;
    private sendJsonMessage;
    private sendTransportFrame;
    /**
     * Send a session message. For fire-and-forget messages (heartbeats, etc.),
     * failures are suppressed if `suppressSendErrors` is configured.
     * For RPC methods that wait for responses, use `sendSessionMessageOrThrow` instead.
     */
    private sendSessionMessage;
    private sendBinaryFrame;
    /**
     * Send a session message for RPC methods that create waiters.
     * If the connection is still being established ("connecting"), the message
     * is queued and will be sent once connected (or rejected after timeout).
     * This prevents waiters from hanging forever when called during connection.
     */
    private sendSessionMessageOrThrow;
    /**
     * Flush pending send queue - called when connection is established.
     */
    private flushPendingSendQueue;
    /**
     * Reject all pending sends - called when connection fails or is closed.
     */
    private rejectPendingSendQueue;
    private sendRequest;
    private sendCorrelatedRequest;
    private sendCorrelatedSessionRequest;
    private sendNamespacedCorrelatedSessionRequest;
    private sendSessionMessageStrict;
    clearAgentAttention(agentId: string | string[]): Promise<void>;
    clearWorkspaceAttention(workspaceId: string | string[]): Promise<void>;
    markWorkspaceUnread(workspaceId: string, requestId?: string): Promise<void>;
    sendHeartbeat(params: {
        deviceType: "web" | "mobile";
        focusedAgentId: string | null;
        focusedTerminalId?: string | null;
        lastActivityAt: string;
        appVisible: boolean;
        appVisibilityChangedAt?: string;
    }): void;
    registerPushToken(token: string): void;
    unregisterPushToken(token: string): Promise<void>;
    ping(params?: {
        requestId?: string;
        timeoutMs?: number;
    }): Promise<{
        requestId: string;
        clientSentAt: number;
        serverReceivedAt: number;
        serverSentAt: number;
        rttMs: number;
    }>;
    measureLatency(params?: {
        timeoutMs?: number;
    }): Promise<number>;
    private livenessPing;
    private sendPingAwaitRtt;
    private startLivenessHeartbeat;
    private stopLivenessHeartbeat;
    private scheduleNextLivenessHeartbeat;
    fetchAgents(options?: FetchAgentsOptions): Promise<FetchAgentsPayload>;
    fetchAgentHistory(options?: FetchAgentHistoryOptions): Promise<FetchAgentHistoryPayload>;
    fetchRecentProviderSessions(options?: FetchRecentProviderSessionsOptions): Promise<FetchRecentProviderSessionsPayload>;
    fetchWorkspaces(options?: FetchWorkspacesOptions): Promise<FetchWorkspacesPayload>;
    listWorkspaceLabels(options: {
        subscriptionId: string;
        sync?: {
            generation: string;
            afterSeq: number;
        };
        requestId?: string;
    }): Promise<WorkspaceLabelListPayload>;
    setWorkspaceLabel(options: {
        workspaceId: string;
        label: Extract<SessionInboundMessage, {
            type: "workspace.label.assignment.set.request";
        }>["label"];
        assigned: boolean;
        requestId?: string;
    }): Promise<WorkspaceLabelAssignmentPayload>;
    updateWorkspaceLabel(options: {
        name: string;
        newName?: string;
        color?: Extract<SessionInboundMessage, {
            type: "workspace.label.update.request";
        }>["color"];
        requestId?: string;
    }): Promise<WorkspaceLabelUpdatePayload>;
    deleteWorkspaceLabel(options: {
        name: string;
        requestId?: string;
    }): Promise<WorkspaceLabelDeletePayload>;
    inspectWorkspaceLabelDelete(options: {
        name: string;
        requestId?: string;
    }): Promise<WorkspaceLabelDeleteInspectPayload>;
    listProjects(options?: string | ProjectListOptions): Promise<ProjectListPayload>;
    openProject(cwd: string, requestId?: string): Promise<OpenProjectPayload>;
    addProject(cwd: string, requestId?: string): Promise<ProjectAddPayload>;
    createProjectDirectory(input: {
        parentPath: string;
        name: string;
    }, requestId?: string): Promise<ProjectCreateDirectoryPayload>;
    searchGithubRepositories(input: {
        query: string;
        limit?: number;
    }, requestId?: string): Promise<WorkspaceGithubSearchRepositoriesPayload>;
    cloneGithubProject(input: {
        repo: string;
        targetDirectory: string;
        cloneProtocol?: ProjectGithubCloneProtocol;
    }, requestId?: string): Promise<ProjectGithubClonePayload>;
    startWorkspaceScript(workspaceId: string, scriptName: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
        type: "start_workspace_script_response";
    }>["payload"]>;
    listWorkspaceScripts(workspaceId: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
        type: "workspace.script.list.response";
    }>["payload"]>;
    startWorkspaceScriptWithStatus(workspaceId: string, scriptName: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
        type: "workspace.script.start.response";
    }>["payload"]>;
    stopWorkspaceScript(workspaceId: string, scriptName: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
        type: "workspace.script.stop.response";
    }>["payload"]>;
    archiveWorkspace(workspaceId: string, requestId?: string): Promise<ArchiveWorkspacePayload>;
    fetchWorkspaceSetupStatus(workspaceId: string, requestId?: string): Promise<WorkspaceSetupStatusPayload>;
    runWorkspaceSetup(workspaceId: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
        type: "workspace.setup.run.response";
    }>["payload"]>;
    fetchAgent(options: FetchAgentOptions): Promise<FetchAgentResult | null>;
    fetchAgent(agentId: string, requestId?: string): Promise<FetchAgentResult | null>;
    fetchAgent(agentId: string, options?: LegacyFetchAgentOptions): Promise<FetchAgentResult | null>;
    private resubscribeCheckoutDiffSubscriptions;
    private resubscribeTerminalDirectorySubscriptions;
    private resubscribeFileSubscriptions;
    createAgent(options: CreateAgentRequestOptions): Promise<AgentSnapshotPayload>;
    private requireAgentRequestReceipts;
    deleteAgent(agentId: string): Promise<void>;
    archiveAgent(agentId: string): Promise<{
        archivedAt: string;
    }>;
    detachAgent(agentId: string): Promise<void>;
    updateAgent(agentId: string, updates: {
        name?: string;
        labels?: Record<string, string>;
    }): Promise<void>;
    renameProject(projectId: string, customName: string | null, requestId?: string): Promise<{
        customName: string | null;
    }>;
    setProjectIcon(projectId: string, source: ProjectIconSource, requestId?: string): Promise<void>;
    removeProject(projectId: string, requestId?: string): Promise<{
        removedWorkspaceIds: string[];
    }>;
    setWorkspaceTitle(workspaceId: string, title: string | null, requestId?: string): Promise<{
        title: string | null;
    }>;
    setWorkspacePinned(workspaceId: string, pinned: boolean, requestId?: string): Promise<{
        pinnedAt: string | null;
    }>;
    inspectWorkspaceRecovery(workspaceId: string, requestId?: string): Promise<WorkspaceRecoveryState>;
    restoreWorkspace(workspaceId: string, requestId?: string): Promise<void>;
    resumeAgent(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>): Promise<AgentSnapshotPayload>;
    importAgent(input: ImportAgentInput): Promise<AgentSnapshotPayload>;
    refreshAgent(agentId: string, requestId?: string): Promise<AgentRefreshedStatusPayload>;
    fetchAgentTimeline(agentId: string, options?: FetchAgentTimelineOptions): Promise<FetchAgentTimelinePayload>;
    appendAgentTimelineItem(agentId: string, item: Omit<import("@getpaseo/protocol/agent-types").PluginTimelineItem, "pluginId">): Promise<{
        seq: number;
        epoch: string;
    }>;
    listAgentTimelinePrompts(agentId: string, options?: {
        requestId?: string;
        timeout?: number;
    }): Promise<AgentTimelinePromptIndexPayload>;
    listProviderSubagents(parentAgentId: string, options?: {
        requestId?: string;
        timeout?: number;
    }): Promise<ProviderSubagentListPayload>;
    fetchProviderSubagentTimeline(parentAgentId: string, subagentId: string, options?: FetchProviderSubagentTimelineOptions): Promise<ProviderSubagentTimelinePayload>;
    setAgentTimelineSubscription(agentIds: string[]): Promise<void>;
    subscribeAgentTimeline(agentId: string, handler: (message: Extract<SessionOutboundMessage, {
        type: "agent_stream" | "agent.timeline.replacement";
    }>) => void): TimelineSubscription;
    private updateEventSubscriptions;
    private sendEventSubscription;
    private sendTimelineSubscription;
    buildAgentForkContext(agentId: string, options?: AgentForkContextOptions): Promise<AgentForkContextPayload>;
    sendAgentMessage(agentId: string, text: string, options?: SendMessageOptions): Promise<void>;
    sendMessage(agentId: string, text: string, options?: SendMessageOptions): Promise<void>;
    rewindAgent(agentId: string, messageId: string, mode: "conversation" | "files" | "both"): Promise<AgentRewindResponseMessage["payload"]>;
    cancelAgent(agentId: string): Promise<void>;
    setAgentMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
    setAgentModel(agentId: string, modelId: string | null): Promise<void>;
    setAgentFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
    setAgentThinkingOption(agentId: string, thinkingOptionId: string | null): Promise<AgentProviderNotice | null>;
    /**
     * Applies a whole agent-config bundle in one request. Use this instead of
     * chaining the single-field setters when the values belong together so client
     * interruption and other mutations cannot interleave between steps. A
     * provider rejection can still leave earlier steps applied.
     * Gated on `server_info.features.agentConfigApply`.
     */
    applyAgentConfig(agentId: string, config: AgentConfigApply): Promise<AgentProviderNotice | null>;
    restartServer(reason?: string, requestId?: string): Promise<RestartRequestedStatusPayload>;
    shutdownServer(options?: ShutdownServerOptions): Promise<ShutdownRequestedStatusPayload>;
    updateDaemon(requestId?: string): Promise<DaemonUpdateResponse["payload"]>;
    setVoiceMode(enabled: boolean, agentId?: string): Promise<SetVoiceModePayload>;
    sendVoiceAudioChunk(audio: string, format: string, isLast?: boolean): Promise<void>;
    startDictationStream(dictationId: string, format: string): Promise<void>;
    sendDictationStreamChunk(dictationId: string, seq: number, audio: string, format: string): void;
    finishDictationStream(dictationId: string, finalSeq: number): Promise<{
        dictationId: string;
        text: string;
    }>;
    cancelDictationStream(dictationId: string): void;
    abortRequest(): Promise<void>;
    audioPlayed(id: string): Promise<void>;
    getCheckoutStatus(cwd: string, options?: {
        requestId?: string;
    }): Promise<CheckoutStatusPayload>;
    private normalizeCheckoutDiffCompare;
    getCheckoutDiff(cwd: string, compare: {
        mode: "uncommitted" | "base";
        baseRef?: string;
        ignoreWhitespace?: boolean;
    }, requestId?: string): Promise<CheckoutDiffPayload>;
    subscribeCheckoutDiff(cwd: string, compare: {
        mode: "uncommitted" | "base";
        baseRef?: string;
        ignoreWhitespace?: boolean;
    }, options?: {
        subscriptionId?: string;
        requestId?: string;
    }): Promise<SubscribeCheckoutDiffPayload>;
    unsubscribeCheckoutDiff(subscriptionId: string): void;
    checkoutCommit(cwd: string, input: {
        message?: string;
        addAll?: boolean;
    }, requestId?: string): Promise<CheckoutCommitPayload>;
    checkoutMerge(cwd: string, input: {
        baseRef?: string;
        strategy?: "merge" | "squash";
        requireCleanTarget?: boolean;
    }, requestId?: string): Promise<CheckoutMergePayload>;
    checkoutMergeFromBase(cwd: string, input: {
        baseRef?: string;
        requireCleanTarget?: boolean;
    }, requestId?: string): Promise<CheckoutMergeFromBasePayload>;
    checkoutPull(cwd: string, requestId?: string): Promise<CheckoutPullPayload>;
    checkoutPush(cwd: string, requestId?: string): Promise<CheckoutPushPayload>;
    checkoutRefresh(cwd: string, requestId?: string): Promise<CheckoutRefreshPayload>;
    listCheckoutCommits(cwd: string, requestId?: string): Promise<{
        baseRef: string | null;
        commits: CheckoutCommit[];
    }>;
    getCommitFileDiff(cwd: string, sha: string, path: string, requestId?: string): Promise<{
        file: ParsedDiffFile | null;
    }>;
    checkoutPrCreate(cwd: string, input: {
        title?: string;
        body?: string;
        baseRef?: string;
    }, requestId?: string): Promise<CheckoutPrCreatePayload>;
    checkoutPrMerge(cwd: string, input: {
        method: CheckoutPrMergeMethod;
    }, requestId?: string): Promise<CheckoutPrMergePayload>;
    checkoutForgeSetAutoMerge(cwd: string, input: {
        enabled: true;
        method: CheckoutPrMergeMethod;
    } | {
        enabled: false;
    }, requestId?: string): Promise<CheckoutForgeSetAutoMergePayload>;
    checkoutGithubSetAutoMerge(cwd: string, input: {
        enabled: true;
        method: CheckoutPrMergeMethod;
    } | {
        enabled: false;
    }, requestId?: string): Promise<CheckoutGithubSetAutoMergePayload>;
    checkoutForgeGetCheckDetails(input: {
        cwd: string;
        repoOwner?: string;
        repoName?: string;
        checkRunId?: number;
        workflowRunId?: number;
        changeRequestNumber?: number;
    }, requestId?: string): Promise<CheckoutForgeGetCheckDetailsPayload>;
    checkoutGithubGetCheckDetails(input: {
        cwd: string;
        repoOwner?: string;
        repoName?: string;
        checkRunId?: number;
        workflowRunId?: number;
    }, requestId?: string): Promise<CheckoutGithubGetCheckDetailsPayload>;
    checkoutPrStatus(cwd: string, requestId?: string): Promise<CheckoutPrStatusPayload>;
    pullRequestTimeline(input: {
        cwd: string;
        prNumber: number;
        repoOwner: string;
        repoName: string;
    }, requestId?: string): Promise<PullRequestTimelinePayload>;
    checkoutSwitchBranch(cwd: string, branch: string, requestId?: string): Promise<CheckoutSwitchBranchPayload>;
    renameBranch(input: RenameBranchInput): Promise<RenameBranchResult>;
    stashSave(cwd: string, options?: {
        branch?: string;
    }, requestId?: string): Promise<StashSavePayload>;
    stashPop(cwd: string, stashIndex: number, requestId?: string): Promise<StashPopPayload>;
    stashList(cwd: string, options?: {
        paseoOnly?: boolean;
    }, requestId?: string): Promise<StashListPayload>;
    getPaseoWorktreeList(input: {
        cwd?: string;
        repoRoot?: string;
    }, requestId?: string): Promise<PaseoWorktreeListPayload>;
    archivePaseoWorktree(input: {
        worktreePath?: string;
        repoRoot?: string;
        branchName?: string;
        workspaceId?: string;
        scope?: "workspace" | "worktree";
    }, requestId?: string): Promise<PaseoWorktreeArchivePayload>;
    createPaseoWorktree(input: CreatePaseoWorktreeInput, requestId?: string): Promise<CreatePaseoWorktreePayload>;
    createWorkspace(input: {
        source: WorkspaceCreateRequest["source"];
        title?: string;
        firstAgentContext?: WorkspaceCreateRequest["firstAgentContext"];
    }, requestId?: string): Promise<WorkspaceCreatePayload>;
    validateBranch(options: {
        cwd: string;
        branchName: string;
    }, requestId?: string): Promise<ValidateBranchPayload>;
    getBranchSuggestions(options: {
        cwd: string;
        query?: string;
        limit?: number;
    }, requestId?: string): Promise<BranchSuggestionsPayload>;
    searchForge(options: {
        cwd: string;
        query: string;
        limit?: number;
        kinds?: ForgeSearchRequest["kinds"];
    }, requestId?: string): Promise<ForgeSearchPayload>;
    searchGitHub(options: {
        cwd: string;
        query: string;
        limit?: number;
        kinds?: GitHubSearchRequest["kinds"];
    }, requestId?: string): Promise<GitHubSearchPayload>;
    getDirectorySuggestions(options: {
        query: string;
        limit?: number;
        cwd?: string;
        includeFiles?: boolean;
        includeDirectories?: boolean;
        matchMode?: "fuzzy" | "suffix";
    }, requestId?: string): Promise<DirectorySuggestionsPayload>;
    private requestFileExplorer;
    listDirectory(cwd: string, path: string, requestId?: string): Promise<FileExplorerDirectoryPayload>;
    readFile(cwd: string, path: string, requestId?: string, maxBytes?: number): Promise<FileReadResult>;
    subscribeFile(input: {
        cwd: string;
        path: string;
    }, onUpdate: (version: FileVersion) => void): Promise<{
        initial: FileVersion;
        unsubscribe: () => void;
    }>;
    writeFile(input: {
        cwd: string;
        path: string;
        content: string;
        expectedModifiedAt: string;
        expectedRevision?: string;
    }): Promise<FileWriteResult>;
    createFileEntry(input: {
        cwd: string;
        parentPath: string;
        name: string;
        kind: "file" | "directory";
    }): Promise<CorrelatedResponsePayload<"fs.entry.create.response">>;
    renameFileEntry(input: {
        cwd: string;
        path: string;
        name: string;
    }): Promise<CorrelatedResponsePayload<"fs.entry.rename.response">>;
    duplicateFileEntry(input: {
        cwd: string;
        path: string;
    }): Promise<CorrelatedResponsePayload<"fs.entry.duplicate.response">>;
    deleteFileEntry(input: {
        cwd: string;
        path: string;
    }): Promise<CorrelatedResponsePayload<"fs.entry.delete.response">>;
    checkoutDiscardChanges(cwd: string, input: {
        paths: string[];
    }): Promise<CorrelatedResponsePayload<"checkout.discard_changes.response">>;
    uploadFile(input: FileUploadInput): Promise<FileUploadResult>;
    requestDownloadToken(cwd: string, path: string, requestId?: string): Promise<FileDownloadTokenPayload>;
    requestProjectIcon(cwd: string, requestId?: string): Promise<ProjectIconResponse["payload"]>;
    getProjectIcon(projectId: string, requestId?: string): Promise<ProjectIconGetResponse["payload"]>;
    listProviderModels(provider: AgentProvider, options?: {
        cwd?: string;
        requestId?: string;
    }): Promise<ListProviderModelsPayload>;
    listProviderModes(provider: AgentProvider, options?: {
        cwd?: string;
        requestId?: string;
    }): Promise<ListProviderModesPayload>;
    listProviderFeatures(draftConfig: ListCommandsDraftConfig, options?: {
        requestId?: string;
    }): Promise<ListProviderFeaturesPayload>;
    listAvailableProviders(options?: {
        requestId?: string;
    }): Promise<ListAvailableProvidersPayload>;
    getProvidersSnapshot(options?: {
        cwd?: string;
        ifNoneMatch?: string;
        requestId?: string;
    }): Promise<GetProvidersSnapshotPayload>;
    private requestProvidersSnapshot;
    getDaemonConfig(requestId?: string): Promise<{
        requestId: string;
        config: MutableDaemonConfig;
    }>;
    getDaemonStatus(options?: DaemonStatusOptions): Promise<DaemonStatusPayload>;
    reloadDaemonConfig(requestId?: string): Promise<DaemonConfigReloadResponse["payload"]>;
    connectHub(hubUrl: string, token: string, permissions?: readonly string[], requestId?: string): Promise<{
        requestId: string;
        status: {
            state: "connecting" | "connected" | "not_connected" | "reconnecting" | "disconnecting" | "revoked";
            daemonId: string | null;
            hubOrigin: string | null;
            permissions: ("daemon.read" | "daemon.manage" | "tunnel.manage" | "access.manage" | "workspace.read" | "workspace.write" | "workspace.manage" | "automation.manage" | "hub.execute")[];
            connectedAt: string | null;
            lastError: string | null;
        };
    }>;
    updateHubPermissions(input: {
        grant?: readonly string[];
        revoke?: readonly string[];
    }, requestId?: string): Promise<{
        requestId: string;
        status: {
            state: "connecting" | "connected" | "not_connected" | "reconnecting" | "disconnecting" | "revoked";
            daemonId: string | null;
            hubOrigin: string | null;
            permissions: ("daemon.read" | "daemon.manage" | "tunnel.manage" | "access.manage" | "workspace.read" | "workspace.write" | "workspace.manage" | "automation.manage" | "hub.execute")[];
            connectedAt: string | null;
            lastError: string | null;
        };
    }>;
    getHubStatus(requestId?: string): Promise<{
        requestId: string;
        status: {
            state: "connecting" | "connected" | "not_connected" | "reconnecting" | "disconnecting" | "revoked";
            daemonId: string | null;
            hubOrigin: string | null;
            permissions: ("daemon.read" | "daemon.manage" | "tunnel.manage" | "access.manage" | "workspace.read" | "workspace.write" | "workspace.manage" | "automation.manage" | "hub.execute")[];
            connectedAt: string | null;
            lastError: string | null;
        };
    }>;
    disconnectHub(force?: boolean, requestId?: string): Promise<{
        requestId: string;
        status: {
            state: "connecting" | "connected" | "not_connected" | "reconnecting" | "disconnecting" | "revoked";
            daemonId: string | null;
            hubOrigin: string | null;
            permissions: ("daemon.read" | "daemon.manage" | "tunnel.manage" | "access.manage" | "workspace.read" | "workspace.write" | "workspace.manage" | "automation.manage" | "hub.execute")[];
            connectedAt: string | null;
            lastError: string | null;
        };
        warning?: string | undefined;
    }>;
    getDaemonPairingOffer(options?: DaemonPairingOfferOptions): Promise<DaemonPairingOfferPayload>;
    collectDiagnostics(requestId?: string): Promise<DiagnosticsPayload>;
    patchDaemonConfig(config: MutableDaemonConfigPatch, requestId?: string): Promise<{
        requestId: string;
        config: MutableDaemonConfig;
    }>;
    sendBrowserAutomationExecuteResponse(response: BrowserAutomationExecuteResponse): void;
    readProjectConfig(repoRoot: string, requestId?: string): Promise<ReadProjectConfigPayload>;
    writeProjectConfig(input: WriteProjectConfigInput): Promise<WriteProjectConfigPayload>;
    refreshProvidersSnapshot(options?: {
        cwd?: string;
        providers?: AgentProvider[];
        requestId?: string;
    }): Promise<RefreshProvidersSnapshotPayload>;
    getProviderDiagnostic(provider: AgentProvider, options?: {
        requestId?: string;
    }): Promise<ProviderDiagnosticPayload>;
    listProviderUsage(options?: {
        requestId?: string;
    }): Promise<ProviderUsageListPayload>;
    listCommands(options: ListCommandsOptions): Promise<ListCommandsPayload>;
    listCommands(agentId: string, requestId?: string): Promise<ListCommandsPayload>;
    listCommands(agentId: string, options?: LegacyListCommandsOptions): Promise<ListCommandsPayload>;
    respondToPermission(agentId: string, requestId: string, response: AgentPermissionResponse): Promise<void>;
    getPluginCatalog(): Promise<{
        id: string;
        clientBundle: string;
        requirements?: {
            paseo?: string | undefined;
        } | undefined;
    }[]>;
    listPlugins(): Promise<PluginListItem[]>;
    getPluginLogs(pluginId: string): Promise<PluginLogEntry[]>;
    getAgentSkillsStatus(): Promise<AgentSkillsStatus>;
    reconcileAgentSkills(): Promise<AgentSkillsStatus>;
    uninstallAgentSkills(): Promise<AgentSkillsStatus>;
    saveAgentSkillsSelection(selection: AgentSkillSelection, confirmedRemovals?: readonly string[]): Promise<AgentSkillsSaveResult>;
    importLegacyAgentSkillsSelection(selection: AgentSkillSelection): Promise<{
        imported: boolean;
        selection: AgentSkillSelection;
    }>;
    installDirectoryPlugin(path: string, id?: string): Promise<PluginListItem>;
    installPluginSource(input: {
        source: string;
        id?: string;
        ref?: string;
    }): Promise<PluginListItem>;
    getPluginSourceStatus(pluginId?: string): Promise<PluginSourceStatusItem[]>;
    updatePluginSources(pluginId?: string): Promise<PluginSourceUpdateItem[]>;
    inspectDirectoryPlugin(path: string): Promise<{
        id: string;
    }>;
    reloadPlugin(pluginId: string): Promise<PluginListItem>;
    enablePlugin(pluginId: string): Promise<PluginListItem>;
    disablePlugin(pluginId: string): Promise<PluginListItem>;
    removePlugin(pluginId: string): Promise<void>;
    private managePlugin;
    invokePluginRpc(pluginId: string, method: string, input: unknown): Promise<unknown>;
    respondToPermissionAndWait(agentId: string, requestId: string, response: AgentPermissionResponse, timeout?: number): Promise<AgentPermissionResolvedPayload>;
    waitForAgentUpsert(agentId: string, predicate: (snapshot: AgentSnapshotPayload) => boolean, timeout?: number): Promise<AgentSnapshotPayload>;
    waitForFinish(agentId: string, timeout?: number): Promise<WaitForFinishResult>;
    subscribeTerminals(input: {
        cwd: string;
        workspaceId?: string;
    }): void;
    unsubscribeTerminals(input: {
        cwd: string;
        workspaceId?: string;
    }): void;
    listTerminals(cwd?: string, requestId?: string, options?: {
        workspaceId?: string;
    }): Promise<ListTerminalsPayload>;
    createTerminal(cwd: string, name?: string, requestId?: string, options?: {
        agentId?: string;
        command?: string;
        args?: string[];
        workspaceId?: string;
        size?: {
            rows: number;
            cols: number;
        };
    }): Promise<CreateTerminalPayload>;
    renameTerminal(input: RenameTerminalInput): Promise<RenameTerminalResult>;
    subscribeTerminal(terminalId: string, optionsOrRequestId?: {
        restore?: SubscribeTerminalRequest["restore"];
        requestId?: string;
    } | string): Promise<SubscribeTerminalPayload>;
    unsubscribeTerminal(terminalId: string): void;
    sendTerminalInput(terminalId: string, message: TerminalInput["message"]): void;
    killTerminal(terminalId: string, requestId?: string): Promise<KillTerminalPayload>;
    closeItems(input: {
        agentIds?: string[];
        terminalIds?: string[];
    }, requestId?: string): Promise<CloseItemsPayload>;
    captureTerminal(terminalId: string, options?: {
        start?: number;
        end?: number;
        stripAnsi?: boolean;
    }, requestId?: string): Promise<CaptureTerminalPayload>;
    scheduleCreate(options: CreateScheduleOptions): Promise<ScheduleCreatePayload>;
    scheduleList(requestId?: string): Promise<ScheduleListPayload>;
    scheduleInspect(options: InspectScheduleOptions): Promise<ScheduleInspectPayload>;
    scheduleLogs(options: InspectScheduleOptions): Promise<ScheduleLogsPayload>;
    schedulePause(options: InspectScheduleOptions): Promise<SchedulePausePayload>;
    scheduleResume(options: InspectScheduleOptions): Promise<ScheduleResumePayload>;
    scheduleDelete(options: InspectScheduleOptions): Promise<ScheduleDeletePayload>;
    scheduleRunOnce(options: InspectScheduleOptions): Promise<ScheduleRunOncePayload>;
    scheduleUpdate(options: UpdateScheduleOptions): Promise<ScheduleUpdatePayload>;
    onTerminalStreamEvent(handler: (event: TerminalStreamEvent) => void): () => void;
    waitForTerminalStreamEvent(predicate: (event: TerminalStreamEvent) => boolean, timeout?: number): Promise<TerminalStreamEvent>;
    private createRequestId;
    getLastServerInfoMessage(): ServerInfoStatusPayload | null;
    private requireHubRelationshipSupport;
    private requireDaemonConfigReloadSupport;
    private resolveTransportUrlForAttempt;
    private sendHelloMessage;
    private disposeTransport;
    private cleanupTransport;
    private resetConnectTimeout;
    private handleTransportMessage;
    private handleJsonPayload;
    private tryHandleBinaryFrame;
    private handleFileTransferFrame;
    private updateConnectionState;
    setReconnectEnabled(enabled: boolean): void;
    private scheduleReconnect;
    private emitDisconnectedStateForReconnect;
    private armReconnectTimer;
    private resolvePingProbe;
    private clearPingProbe;
    private rejectPingProbe;
    private recordLivenessFailure;
    private handleSessionMessage;
    private deliverSessionMessage;
    private resolveWaiters;
    private rejectWaitersForRequestId;
    private clearWaiters;
    private toEvent;
    private waitForWithCancel;
}
//# sourceMappingURL=daemon-client.d.ts.map