import type { DaemonClientConfig } from "./daemon-client.js";
import type { AgentPermissionResponse } from "@getpaseo/protocol/agent-types";
import type { AgentSnapshotPayload, CreateAgentRequestMessage, FetchWorkspacesRequestMessage, FetchWorkspacesResponseMessage, GetProvidersSnapshotResponseMessage, ListAvailableProvidersResponse, ListCommandsResponse, ListProviderFeaturesRequestMessage, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ProjectListRequestMessage, ProjectListResponseMessage, ListProviderModesResponseMessage, MutableDaemonConfig, MutableDaemonConfigPatch, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, ProjectPlacementPayload, WorkspaceProjectDescriptorPayload, RefreshProvidersSnapshotResponseMessage, SendAgentMessageRequest, SessionOutboundMessage, WorkspaceDescriptorPayload, WorkspaceCreateRequest } from "@getpaseo/protocol/messages";
import { DaemonClient } from "./daemon-client.js";
import { type PaseoTerminalActions, type PaseoWorkspaceTerminalActions } from "./terminals/index.js";
export type { PaseoTerminal, PaseoTerminalActions, PaseoTerminalHandle, PaseoTerminalCreateOptions, PaseoTerminalListOptions, PaseoTerminalListResult, PaseoTerminalCaptureOptions, PaseoTerminalCaptureResult, PaseoWorkspaceTerminalActions, } from "./terminals/index.js";
import type { PluginTimelineItem } from "@getpaseo/protocol/agent-types";
import type { FetchAgentsEntry, FetchAgentsOptions, FetchAgentsPageInfo, FetchAgentTimelineCursor, FetchAgentTimelineDirection, FetchAgentTimelinePayload, FetchAgentTimelineProjection, WaitForFinishResult } from "./daemon-client.js";
export type ConnectionState = {
    status: "idle";
} | {
    status: "connecting";
    attempt: number;
} | {
    status: "connected";
} | {
    status: "disconnected";
    reason?: string;
} | {
    status: "disposed";
};
export interface PaseoLogger {
    debug(obj: object, msg?: string): void;
    info(obj: object, msg?: string): void;
    warn(obj: object, msg?: string): void;
    error(obj: object, msg?: string): void;
}
export interface PaseoClientConfig {
    capabilities?: DaemonClientConfig["capabilities"];
    url: string;
    clientId?: string;
    appVersion?: string;
    runtimeGeneration?: number | null;
    password?: string;
    authHeader?: string;
    suppressSendErrors?: boolean;
    logger?: PaseoLogger;
    connectTimeoutMs?: number;
    e2ee?: {
        enabled?: boolean;
        daemonPublicKeyB64?: string;
    };
    reconnect?: {
        enabled?: boolean;
        baseDelayMs?: number;
        maxDelayMs?: number;
    };
    runtimeMetricsIntervalMs?: number;
    runtimeMetricsWindowMs?: number;
}
export type PaseoWorkspace = WorkspaceDescriptorPayload;
export type PaseoAgent = AgentSnapshotPayload;
export type PaseoAgentListOptions = FetchAgentsOptions;
export type PaseoProject = WorkspaceProjectDescriptorPayload;
export type PaseoProjectListOptions = Omit<ProjectListRequestMessage, "type" | "requestId"> & {
    requestId?: string;
};
export type PaseoProjectListResult = ProjectListResponseMessage["payload"];
export type PaseoProjectUpdate = Extract<SessionOutboundMessage, {
    type: "project.update";
}>["payload"];
export type PaseoProjectUpdateHandler = (update: PaseoProjectUpdate) => void;
export interface PaseoAgentListResult {
    requestId: string;
    subscriptionId?: string | null;
    entries: FetchAgentsEntry[];
    pageInfo: FetchAgentsPageInfo;
}
export type PaseoWorkspaceListOptions = Omit<FetchWorkspacesRequestMessage, "type" | "requestId"> & {
    requestId?: string;
};
export interface PaseoWorkspaceListResult {
    requestId: string;
    subscriptionId?: string | null;
    entries: PaseoWorkspace[];
    pageInfo: FetchWorkspacesResponseMessage["payload"]["pageInfo"];
}
export interface PaseoWorkspaceOpenOptions {
    cwd: string;
    requestId?: string;
}
export type PaseoWorkspaceCreateOptions = Omit<WorkspaceCreateRequest, "type" | "requestId"> & {
    requestId?: string;
};
export interface PaseoWorkspaceArchiveResult {
    requestId: string;
    workspaceId: string;
    archivedAt: string | null;
    error: string | null;
}
export type PaseoWorkspaceUpdate = Extract<SessionOutboundMessage, {
    type: "workspace_update";
}>["payload"];
export type PaseoWorkspaceUpdateHandler = (update: PaseoWorkspaceUpdate) => void;
export interface PaseoWorkspaceHandle {
    readonly id: string;
    readonly projectId: string | null;
    readonly directory: string | null;
    readonly name: string | null;
    readonly status: PaseoWorkspace["status"] | null;
    readonly agents: {
        create(options: PaseoWorkspaceAgentCreateOptions): Promise<PaseoAgentHandle>;
    };
    readonly terminals: PaseoWorkspaceTerminalActions;
    current(): PaseoWorkspace | null;
    refresh(options?: {
        requestId?: string;
    }): Promise<PaseoWorkspace | null>;
    setTitle(title: string | null, requestId?: string): Promise<{
        title: string | null;
    }>;
    archive(requestId?: string): Promise<PaseoWorkspaceArchiveResult>;
    /**
     * Subscribes to already-emitted daemon workspace_update events for this id.
     * This returns a local unsubscribe function; it does not own app cache state or
     * send a daemon unsubscribe RPC. Call `workspaces.list({ subscribe: {} })` when
     * the daemon should start streaming workspace directory updates.
     */
    subscribe(handler: (update: PaseoWorkspaceUpdate) => void): () => void;
}
export interface PaseoProjectActions {
    list(options?: PaseoProjectListOptions): Promise<PaseoProjectListResult>;
    subscribe(handler: PaseoProjectUpdateHandler): () => void;
}
export interface PaseoWorkspaceActions {
    list(options?: PaseoWorkspaceListOptions): Promise<PaseoWorkspaceListResult>;
    ref(workspace: string | PaseoWorkspace): PaseoWorkspaceHandle;
    open(input: string | PaseoWorkspaceOpenOptions, requestId?: string): Promise<PaseoWorkspaceHandle>;
    create(options: PaseoWorkspaceCreateOptions): Promise<PaseoWorkspaceHandle>;
    archive(workspace: string | PaseoWorkspaceHandle, requestId?: string): Promise<PaseoWorkspaceArchiveResult>;
    /**
     * Local event subscription over the low-level driver's workspace_update stream.
     * The returned function only removes this SDK listener.
     */
    subscribe(handler: PaseoWorkspaceUpdateHandler): () => void;
}
type PaseoAgentSessionConfig = CreateAgentRequestMessage["config"];
export type PaseoAgentProvider = PaseoAgentSessionConfig["provider"];
export type PaseoProviderFeatureValues = Record<string, unknown>;
export interface PaseoAgentConfig {
    /** Provider and model in `provider/model` format. */
    provider: string;
    modeId?: PaseoAgentSessionConfig["modeId"];
    thinkingOptionId?: PaseoAgentSessionConfig["thinkingOptionId"];
    featureValues?: PaseoProviderFeatureValues;
    /** JSON-safe provider-native settings, validated by the selected provider. */
    options?: PaseoAgentSessionConfig["providerOptions"];
    systemPrompt?: PaseoAgentSessionConfig["systemPrompt"];
    toolPolicy?: PaseoAgentSessionConfig["toolPolicy"];
    mcpServers?: PaseoAgentSessionConfig["mcpServers"];
}
export interface PaseoAgentCreateOptions {
    config: PaseoAgentConfig;
    cwd: string;
    parent?: string | PaseoAgentHandle;
    title?: PaseoAgentSessionConfig["title"];
    env?: CreateAgentRequestMessage["env"];
    prompt?: string;
    clientMessageId?: string;
    outputSchema?: Record<string, unknown>;
    images?: CreateAgentRequestMessage["images"];
    attachments?: CreateAgentRequestMessage["attachments"];
    git?: CreateAgentRequestMessage["git"];
    worktree?: CreateAgentRequestMessage["worktree"];
    autoArchive?: CreateAgentRequestMessage["autoArchive"];
    requestId?: string;
    labels?: Record<string, string>;
}
export type PaseoWorkspaceAgentCreateOptions = Omit<PaseoAgentCreateOptions, "cwd">;
export interface PaseoAgentRefetchResult {
    agent: PaseoAgent;
    project: ProjectPlacementPayload | null;
}
export interface PaseoAgentTimelineRefetchOptions {
    direction?: FetchAgentTimelineDirection;
    cursor?: FetchAgentTimelineCursor;
    limit?: number;
    projection?: FetchAgentTimelineProjection;
    requestId?: string;
}
export interface PaseoAgentSendOptions {
    messageId?: string;
    images?: Array<{
        data: string;
        mimeType: string;
    }>;
    attachments?: SendAgentMessageRequest["attachments"];
}
export interface PaseoAgentRunOptions extends PaseoAgentSendOptions {
    timeoutMs?: number;
}
export type PaseoAgentRunResult = WaitForFinishResult;
export type PaseoAgentPermissionResponse = AgentPermissionResponse;
export interface PaseoAgentRespondToPermissionOptions {
    requestId: string;
    response: PaseoAgentPermissionResponse;
}
export interface PaseoAgentCommandsOptions {
    requestId?: string;
}
export type PaseoAgentCommandsResult = ListCommandsResponse["payload"];
export type PaseoAgentUpdate = Extract<SessionOutboundMessage, {
    type: "agent_update";
}>["payload"];
export type PaseoAgentStream = Extract<SessionOutboundMessage, {
    type: "agent_stream";
}>["payload"];
export type PaseoAgentUpdateHandler = (update: PaseoAgentUpdate) => void;
export type PaseoAgentTimelineEvent = PaseoAgentStream | {
    agentId: string;
    event: {
        type: "replacement";
        epoch: string;
    };
};
export type PaseoAgentTimelineSubscription = ReturnType<DaemonClient["subscribeAgentTimeline"]>;
export interface PaseoAgentTimelineHandle {
    append(item: Omit<PluginTimelineItem, "pluginId">): Promise<{
        seq: number;
        epoch: string;
    }>;
    /**
     * Fetches a fresh timeline page through the existing daemon RPC. If the daemon
     * includes an agent snapshot in the response, the parent handle is updated to
     * that value.
     */
    refetch(options?: PaseoAgentTimelineRefetchOptions): Promise<FetchAgentTimelinePayload>;
    /**
     * Subscribe to this agent and restore demand after reconnect. A replacement
     * event invalidates previously fetched history; refetch the page you need.
     * Await the returned unsubscribe function's `ready` promise before starting
     * work that must be observed. It rejects if establishment fails.
     */
    subscribe(handler: (event: PaseoAgentTimelineEvent) => void): PaseoAgentTimelineSubscription;
}
export interface PaseoAgentHandle {
    readonly id: string;
    /**
     * `workspaceId` through `archivedAt` mirror the last snapshot this handle
     * observed. A handle from `ref()` reads `null` for all of them until
     * `refresh()`, `run()`, `waitForFinish()`, a timeline refetch, or
     * `subscribe()` delivers a snapshot. Optional snapshot values also read as
     * `null`; use `current()` when you need to distinguish those states.
     */
    readonly workspaceId: string | null;
    readonly cwd: string | null;
    readonly status: PaseoAgent["status"] | null;
    readonly capabilities: PaseoAgent["capabilities"] | null;
    readonly availableModes: PaseoAgent["availableModes"] | null;
    readonly pendingPermissions: PaseoAgent["pendingPermissions"] | null;
    readonly activeTurn: NonNullable<PaseoAgent["activeTurn"]> | null;
    readonly lastUsage: NonNullable<PaseoAgent["lastUsage"]> | null;
    readonly lastError: NonNullable<PaseoAgent["lastError"]> | null;
    readonly features: NonNullable<PaseoAgent["features"]> | null;
    readonly runtimeInfo: NonNullable<PaseoAgent["runtimeInfo"]> | null;
    readonly archivedAt: NonNullable<PaseoAgent["archivedAt"]> | null;
    readonly timeline: PaseoAgentTimelineHandle;
    current(): PaseoAgent | null;
    refresh(requestId?: string): Promise<PaseoAgentRefetchResult | null>;
    send(text: string, options?: PaseoAgentSendOptions): Promise<void>;
    respondToPermission(options: PaseoAgentRespondToPermissionOptions): Promise<void>;
    /** Sends a prompt and resolves when that turn finishes or needs attention. */
    run(text: string, options?: PaseoAgentRunOptions): Promise<PaseoAgentRunResult>;
    /** Waits for the current turn, including one started with `prompt`. */
    waitForFinish(timeoutMs?: number): Promise<PaseoAgentRunResult>;
    /**
     * Asks the running session for the slash commands and skills it actually
     * loaded. Providers answer from the live session, so this sees built-in and
     * bundled entries that no directory scan can find. The payload carries its own
     * `error` string; a provider that cannot answer reports it there rather than
     * rejecting.
     */
    commands(options?: PaseoAgentCommandsOptions): Promise<PaseoAgentCommandsResult>;
    archive(): Promise<{
        archivedAt: string;
    }>;
    detach(): Promise<void>;
    subscribe(handler: (update: PaseoAgentUpdate) => void): () => void;
}
export interface PaseoAgentActions {
    list(options?: PaseoAgentListOptions): Promise<PaseoAgentListResult>;
    ref(agent: string | PaseoAgent): PaseoAgentHandle;
    create(options: PaseoAgentCreateOptions): Promise<PaseoAgentHandle>;
    /**
     * Local event subscription over the low-level driver's agent_update stream.
     * The returned function only removes this SDK listener.
     */
    subscribe(handler: PaseoAgentUpdateHandler): () => void;
}
export type PaseoProviderModelsResult = ListProviderModelsResponseMessage["payload"];
export type PaseoProviderModesResult = ListProviderModesResponseMessage["payload"];
type PaseoProviderFeaturesDraft = ListProviderFeaturesRequestMessage["draftConfig"];
export interface PaseoProviderFeaturesInput extends Omit<PaseoProviderFeaturesDraft, "provider" | "model"> {
    /** Provider and model in `provider/model` format. */
    provider: string;
}
export type PaseoProviderFeaturesResult = ListProviderFeaturesResponseMessage["payload"];
export type PaseoProviderAvailabilityResult = ListAvailableProvidersResponse["payload"];
export type PaseoProviderSnapshotResult = GetProvidersSnapshotResponseMessage["payload"];
export type PaseoProviderSnapshotUpdate = Extract<SessionOutboundMessage, {
    type: "providers_snapshot_update";
}>["payload"];
export type PaseoProviderRefreshResult = RefreshProvidersSnapshotResponseMessage["payload"];
export type PaseoProviderDiagnosticResult = ProviderDiagnosticResponseMessage["payload"];
export type PaseoProviderUsageResult = ProviderUsageListResponseMessage["payload"];
export interface PaseoProviderUsageOptions {
    requestId?: string;
}
export interface PaseoProviderListOptions {
    cwd?: string;
    requestId?: string;
}
export interface PaseoProviderRefreshOptions {
    cwd?: string;
    providers?: PaseoAgentProvider[];
    requestId?: string;
}
export interface PaseoProviderWaitOptions extends PaseoProviderListOptions {
    timeoutMs?: number;
}
export interface PaseoProviderActions {
    listModels(provider: PaseoAgentProvider, options?: PaseoProviderListOptions): Promise<PaseoProviderModelsResult>;
    listModes(provider: PaseoAgentProvider, options?: PaseoProviderListOptions): Promise<PaseoProviderModesResult>;
    listFeatures(draftConfig: PaseoProviderFeaturesInput, options?: {
        requestId?: string;
    }): Promise<PaseoProviderFeaturesResult>;
    listAvailable(options?: {
        requestId?: string;
    }): Promise<PaseoProviderAvailabilityResult>;
    snapshot(options?: PaseoProviderListOptions): Promise<PaseoProviderSnapshotResult>;
    /** Resolves after the daemon's lazy provider discovery has finished. */
    waitForReady(options?: PaseoProviderWaitOptions): Promise<PaseoProviderSnapshotResult>;
    refresh(options?: PaseoProviderRefreshOptions): Promise<PaseoProviderRefreshResult>;
    diagnostic(provider: PaseoAgentProvider, options?: {
        requestId?: string;
    }): Promise<PaseoProviderDiagnosticResult>;
    listUsage(options?: PaseoProviderUsageOptions): Promise<PaseoProviderUsageResult>;
    subscribe(handler: (update: PaseoProviderSnapshotUpdate) => void): () => void;
}
export interface PaseoConfigActions {
    /**
     * Reads daemon config through the existing config RPC. Provider profiles,
     * custom provider entries, keys/env, custom binaries, and provider enablement
     * are currently config-file-shaped daemon state, so the SDK exposes this raw
     * typed surface instead of pretending there are higher-level provider-settings
     * RPCs.
     */
    get(requestId?: string): Promise<{
        requestId: string;
        config: MutableDaemonConfig;
    }>;
    /**
     * Patches daemon config through the existing config RPC. The daemon validates
     * and persists supported fields; unsupported provider/settings workflows remain
     * daemon gaps until first-class RPCs exist.
     */
    patch(config: MutableDaemonConfigPatch, requestId?: string): Promise<{
        requestId: string;
        config: MutableDaemonConfig;
    }>;
}
export interface PaseoApi {
    readonly terminals: PaseoTerminalActions;
    readonly workspaces: PaseoWorkspaceActions;
    readonly projects: PaseoProjectActions;
    readonly agents: PaseoAgentActions;
    readonly providers: PaseoProviderActions;
    readonly config: PaseoConfigActions;
}
export interface PaseoClient extends PaseoApi {
    connect(): Promise<void>;
    close(): Promise<void>;
    ensureConnected(): void;
    getConnectionState(): ConnectionState;
}
export declare function createPaseoClient(config: PaseoClientConfig): PaseoClient;
export declare function createPaseoApi(daemonClient: DaemonClient): PaseoApi;
//# sourceMappingURL=index.d.ts.map