/**
 * Centralized RPC Method Protocolall JSON-RPC request methods
 * that qlogicagent exposes to external apps.
 *
 * This is the SINGLE SOURCE OF TRUTH for the agent's inbound API contract.
 *
 * Reference: Codex app-server RPC, Claude Code JSON-RPC, GitHub Copilot Agent API.
 */
import type { ChatMessage, LocalizedToolText, ToolCapabilityCategory } from "./wire/chat-types.js";
import type { AgentDescriptor, AgentConfig, GatewayRpcMethodMap, RpcProjectInfo, RpcProjectType, RpcProjectStatus, SoloStatus, ProductStatus, ProductSummary } from "./wire/index.js";
import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, SoloMessageParams, SoloEvaluateParams, SoloEvaluation, ProductCreateParams, ProductPlanParams, ProductPlan, ProductConfirmParams, ProductMessageParams, ProductIdParams, ProductDeleteParams } from "./wire/acp-agent-management.js";
export interface InitializeParams {
    protocolVersion: string;
    host?: {
        name: string;
        version: string;
    };
    /** Legacy flat form. */
    hostName?: string;
    hostVersion?: string;
    capabilities?: {
        streaming?: boolean;
        toolApproval?: boolean;
        threads?: boolean;
    };
    config?: Record<string, unknown>;
}
export interface InitializeResult {
    protocolVersion: string;
    agent: {
        name: string;
        version: string;
    };
    capabilities: {
        tools: string[];
        streaming: boolean;
        threads: boolean;
        /** New: list of notification methods the agent can emit. */
        notifications: string[];
        /** New: list of RPC methods the agent supports. */
        methods: string[];
    };
}
export interface ThreadCreateParams {
    id?: string;
    title?: string;
    cwd?: string;
    config?: Record<string, unknown>;
}
export interface ThreadCreateResult {
    id: string;
    title?: string;
    status: "active";
    createdAt: string;
}
export interface ThreadListParams {
    limit?: number;
}
export interface ThreadListResult {
    threads: Array<{
        id: string;
        title?: string;
        status: "active" | "archived";
        turnCount?: number;
        createdAt: string;
        lastActiveAt: string;
    }>;
}
export interface SessionResumeParams {
    sessionId: string;
}
export interface SessionResumeResult {
    metadata: {
        sessionId: string;
        projectId: string;
        createdAt: string;
        lastActiveAt: string;
        model?: string;
        cwd?: string;
        turnCount: number;
        messageCount: number;
        title?: string;
        totalInputTokens?: number;
        totalOutputTokens?: number;
    };
    messages: ChatMessage[];
}
export interface SessionGetInfoParams {
    sessionId?: string;
}
export interface SessionGetInfoResult {
    sessionId: string;
    /** Persistent storage paths for this session. */
    paths: {
        /** Session directory (~/.qlogicagent/sessions/<id>/). */
        sessionDir: string;
        /** Transcript file path. */
        transcript: string;
        /** Session state file path. */
        state: string;
        /** Agent home root (~/.qlogicagent/). */
        agentHome: string;
        /** User settings path. */
        settings: string;
        /** Current working directory. */
        cwd: string;
    };
    model?: string;
    provider?: string;
    turnCount: number;
    title?: string;
    /** Cumulative token usage for the session. */
    usage?: {
        totalPromptTokens: number;
        totalCompletionTokens: number;
        totalCost?: number;
    };
}
export type SessionGetMessagesParams = GatewayRpcMethodMap["session.getMessages"]["params"];
export type SessionGetMessagesResult = GatewayRpcMethodMap["session.getMessages"]["result"];
export interface MemoryListParams {
    /** Filter by source: "local" (md files), "store" (in-memory), "qmemory" (remote). */
    source?: "local" | "store" | "qmemory" | "all";
}
export interface MemoryListResult {
    entries: Array<{
        source: "local" | "store" | "qmemory";
        target?: string;
        path?: string;
        entryCount: number;
        charCount: number;
        lastModified?: string;
    }>;
}
export interface MemoryReadParams {
    /** Source to read from. */
    source: "local" | "store" | "qmemory";
    /** Target within source (e.g. "memory", "user"). */
    target?: string;
    /** For local source, file path relative to agent home. */
    path?: string;
}
export interface MemoryReadResult {
    content: string;
    source: string;
    target?: string;
    entryCount: number;
}
export interface MemoryWriteParams {
    source: "local" | "store";
    target?: string;
    content: string;
    /** Write mode: "append" adds to existing, "replace" overwrites. */
    mode?: "append" | "replace";
}
export interface MemoryWriteResult {
    ok: boolean;
    entryCount: number;
    message: string;
}
export interface MemoryDreamParams {
    turnId?: string;
    sessionId: string;
    config?: Record<string, unknown>;
}
export interface MemoryDreamResult {
    accepted: boolean;
    turnId: string;
}
export interface ToolsListParams {
    /** Filter by category. */
    category?: ToolCapabilityCategory;
    /** Include tools that are normally deferred until activated. */
    includeDeferred?: boolean;
    /** Include tools that are installed but currently disabled by provider/config availability. */
    includeUnavailable?: boolean;
}
export interface ToolsListResult {
    tools: Array<{
        id: string;
        name: string;
        category: ToolCapabilityCategory;
        displayName: LocalizedToolText;
        displayDescription: LocalizedToolText;
        fallbackName: string;
        fallbackDescription: string;
        description: string;
        source: "builtin";
        deferred: boolean;
        enabled?: boolean;
        parameters?: Record<string, unknown>;
    }>;
    total: number;
}
export interface SettingsListProvidersResult {
    providers: Array<{
        id: string;
        displayName: string;
        baseUrl: string;
        modelCount: number;
    }>;
}
export interface SettingsAddKeyParams {
    providerId: string;
    key: string;
    label?: string;
}
export interface SettingsAddKeyResult {
    keyId: string;
    providerId: string;
}
export interface SettingsRemoveKeyParams {
    keyId: string;
}
export interface SettingsGetKeyParams {
    keyId: string;
}
export interface SettingsGetKeyResult {
    key: string;
}
export interface SettingsToggleKeyParams {
    keyId: string;
    enabled: boolean;
}
export interface SettingsListModelsParams {
    purpose?: string;
    provider?: string;
}
export interface SettingsListModelsResult {
    models: Array<{
        id: string;
        provider: string;
        model: string;
        displayName: string;
        routeIntents: string[];
        capabilityProfile?: {
            tasks?: string[];
            input_modalities?: string[];
            output_modalities?: string[];
            traits?: string[];
            verification?: Record<string, unknown>;
            cost?: Record<string, unknown>;
        };
        baseUrl?: string;
        enabled: boolean;
    }>;
    grouped: Record<string, Array<{
        id: string;
        provider: string;
        model: string;
        displayName: string;
        routeIntents: string[];
        capabilityProfile?: {
            tasks?: string[];
            input_modalities?: string[];
            output_modalities?: string[];
            traits?: string[];
            verification?: Record<string, unknown>;
            cost?: Record<string, unknown>;
        };
        baseUrl?: string;
        enabled: boolean;
    }>>;
}
export interface SettingsSetActiveModelParams {
    purpose: string;
    modelId: string;
}
export interface SettingsGetActiveModelParams {
    purpose: string;
}
export interface SettingsGetActiveModelResult {
    model: {
        id: string;
        provider: string;
        model: string;
        displayName: string;
        routeIntents: string[];
        capabilityProfile?: {
            tasks?: string[];
            input_modalities?: string[];
            output_modalities?: string[];
            traits?: string[];
            verification?: Record<string, unknown>;
            cost?: Record<string, unknown>;
        };
        enabled: boolean;
    } | null;
    available: boolean;
}
export interface SettingsGetOverviewResult {
    providers: Array<{
        providerId: string;
        baseUrl?: string;
        keyCount: number;
        healthyKeys: number;
        totalKeys: number;
    }>;
    purposes: Record<string, {
        bound: boolean;
        modelId?: string;
        modelName?: string;
        available: boolean;
    }>;
}
export interface SettingsValidateKeyParams {
    providerId: string;
    apiKey: string;
    baseUrl?: string;
}
export interface SettingsValidateKeyResult {
    valid: boolean;
    status: number;
    error?: string;
}
export interface MediaListModelsParams {
    /** Filter by media type (image/video/music/tts/3d/stt/embedding). Omit to list all. */
    mediaType?: string;
}
export interface MediaListModelsResult {
    models: Array<{
        providerId: string;
        providerName: string;
        modelId: string;
        modelName: string;
        mediaType: string;
        /** Fine-grained capability metadata (operations, formats, limits) */
        capabilities?: Record<string, unknown>;
    }>;
}
export interface ConfigGetParams {
    keys?: string[];
}
export interface ConfigGetResult {
    config: Record<string, unknown>;
}
export interface ConfigUpdateParams {
    settings: Record<string, unknown>;
}
export interface ConfigUpdateResult {
    ok: boolean;
    applied: string[];
    rejected?: Array<{
        key: string;
        reason: string;
    }>;
}
export interface CommunityConsentView {
    enabled: boolean;
    methodSharingEnabled: boolean;
    signalsEnabled: boolean;
    encounterEnabled: boolean;
    remoteSynced: boolean;
}
export interface CommunityGetConsentResult {
    ok: boolean;
    remoteAvailable: boolean;
    consent: CommunityConsentView;
    error?: string;
}
export interface CommunitySetConsentParams {
    enabled: boolean;
    methodSharingEnabled?: boolean;
    signalsEnabled?: boolean;
    encounterEnabled?: boolean;
}
export interface CommunitySetConsentResult {
    ok: boolean;
    remoteAvailable: boolean;
    consent: CommunityConsentView;
    warning?: string;
}
export interface CommunityMatchRegistryParams {
    intent: string;
    topK?: 1 | 2 | 3;
    preferOfficial?: boolean;
}
export interface CommunityRegistryMatchResult {
    id: string;
    type: string;
    title: string;
    summary: string;
    capabilityTags: string[];
    sourceTier: CommunityInstallSourceTier;
    trustStage: CommunityInstallTrustStage;
    resourceRiskTier: CommunityInstallRiskTier;
    effectiveRiskTier: CommunityInstallRiskTier;
    latestVersion: string | null;
    canonical: true;
}
export interface CommunityMatchRegistryResult {
    ok: boolean;
    matches: CommunityRegistryMatchResult[];
}
export interface CommunitySharedResource {
    id: string;
    type: string;
    title: string;
    summary: string;
    visibility: string;
    latestVersion: string | null;
    withdrawn: boolean;
    withdrawnAt: string | null;
}
export interface CommunityListSharedResult {
    ok: boolean;
    resources: CommunitySharedResource[];
}
export interface CommunityWithdrawSharedParams {
    resourceId: string;
    reason?: string;
}
export interface CommunityWithdrawSharedResult {
    ok: boolean;
    resource: CommunitySharedResource;
}
export interface CommunityWithdrawAllSharedParams {
    reason?: string;
}
export interface CommunityWithdrawAllSharedResult {
    ok: boolean;
    resources: CommunitySharedResource[];
}
export interface CommunityNotice {
    id: number;
    resourceId: string;
    resourceType: string;
    title: string;
    event: "withdrawn";
    version: string | null;
    reason: string | null;
    read: boolean;
    createdAt: string;
    readAt: string | null;
}
export interface CommunityListNoticesParams {
    includeRead?: boolean;
}
export interface CommunityListNoticesResult {
    ok: boolean;
    notices: CommunityNotice[];
}
export interface CommunityMarkNoticeReadParams {
    noticeId: number;
}
export interface CommunityMarkNoticeReadResult {
    ok: boolean;
    notice: CommunityNotice;
}
export interface CommunityPublishSkillParams {
    id: string;
    title: string;
    summary: string;
    visibility?: "public" | "private";
    tags?: string[];
    manifest: Record<string, unknown>;
    version?: string;
    packageGzipBase64?: string;
}
export interface CommunityPublishedVersion {
    version: string;
    checksum: string;
    sizeBytes: number;
}
export interface CommunityPublishSkillResult {
    ok: boolean;
    resource: CommunitySharedResource;
    version?: CommunityPublishedVersion;
}
export interface CommunityPublishPetParams {
    id: string;
    name: string;
    summary: string;
    persona: string;
    visibility?: "public" | "private";
    tags?: string[];
    traits?: string[];
    assets?: Array<{
        kind: string;
        path: string;
    }>;
}
export interface CommunityPublishPetResult {
    ok: boolean;
    resource: CommunitySharedResource;
    version?: CommunityPublishedVersion;
}
export type CommunitySignalEvent = "installed" | "success" | "fail" | "neutral" | "kept" | "uninstalled" | "endorse" | "error";
export interface CommunityRecordSignalParams {
    resourceId: string;
    event: CommunitySignalEvent;
    attribution?: string;
    metadata?: Record<string, unknown>;
}
export interface CommunityRecordSignalResult {
    ok: boolean;
    accepted: true;
}
export type CommunityTelemetryEvent = "community.journey.view" | "community.share.generated" | "community.sandbox.violation" | "community.desensitization.hit";
export interface CommunityRecordTelemetryParams {
    event: CommunityTelemetryEvent;
    metadata?: Record<string, unknown>;
}
export interface CommunityRecordTelemetryResult {
    ok: boolean;
    accepted: true;
}
export interface CommunityListPublishAuditParams {
    limit?: number;
}
export interface CommunityPublishAuditEntry {
    eventTurnId: string;
    skillName: string;
    decision: "published" | "blocked" | "skipped";
    reason: string;
    resourceId?: string;
    createdAt: string;
}
export interface CommunityListPublishAuditResult {
    ok: boolean;
    entries: CommunityPublishAuditEntry[];
}
export type CommunityInstallRiskTier = "R0" | "R1" | "R2" | "R3";
export type CommunityInstallSourceTier = "official" | "community";
export type CommunityInstallTrustStage = "quarantine" | "trial" | "trusted";
export type CommunityInstallReviewStatus = "pending" | "approved" | "rejected";
export interface CommunityInstallResolution {
    id: string;
    type: string;
    kind: string;
    sourceTier: CommunityInstallSourceTier;
    trustStage: CommunityInstallTrustStage;
    reviewStatus: CommunityInstallReviewStatus;
    resourceRiskTier: CommunityInstallRiskTier;
    effectiveRiskTier: CommunityInstallRiskTier;
    requires: string[];
    dependencies: CommunityInstallResolution[];
    version: string;
    checksum: string;
    sizeBytes: number;
    downloadUrl: string;
    manifest: unknown;
}
export interface CommunityResolveInstallParams {
    resourceId: string;
    version?: string;
    explicitInstallConsent: true;
    explicitHighRiskConsent?: true;
}
export interface CommunityResolveInstallResult {
    ok: boolean;
    install: CommunityInstallResolution;
}
export interface CommunityInstallResourceParams {
    resourceId: string;
    version?: string;
    explicitInstallConsent: true;
}
export interface CommunityInstalledResource {
    resourceId: string;
    version: string;
    skillName: string;
    installDir: string;
    checksum: string;
}
export type CommunityInstallResourcePreview = {
    kind: "mcp";
    mode: "preview";
    resourceId: string;
    version: string;
    sourceTier: CommunityInstallSourceTier;
    perUseConsentRequired: true;
    declaredPermissions: string[];
    manifest: unknown;
} | {
    kind: "executable";
    mode: "launcher-required" | "manual-review-required";
    resourceId: string;
    version: string;
    resourceType: string;
    sourceTier: CommunityInstallSourceTier;
    riskTier: CommunityInstallRiskTier;
    artifactDigest: string;
    launcherRequired: true;
    manualReviewRequired: boolean;
    autoRunBlocked: true;
    manifest: unknown;
};
export interface CommunityInstallResourceResult {
    ok: boolean;
    installed?: CommunityInstalledResource;
    preview?: CommunityInstallResourcePreview;
    signalWarning?: string;
}
export interface CommunityRuntimeStatusParams {
    ids: string[];
}
export interface CommunityRuntimeDependencyStatus {
    id: string;
    known: boolean;
    label?: string;
    present: boolean;
    version?: string;
    binPath?: string;
    quick?: boolean;
    estSizeMB?: number;
    docsUrl?: string;
}
export interface CommunityRuntimeStatusResult {
    ok: boolean;
    items: CommunityRuntimeDependencyStatus[];
}
export interface CommunityInstallRuntimeParams {
    id: string;
}
export interface CommunityInstallRuntimeResult {
    ok: boolean;
    id: string;
    version?: string;
    binPath?: string;
}
export interface TodosListParams {
    /** Filter by status. */
    status?: "not-started" | "in-progress" | "completed" | "all";
}
export interface TodoItem {
    id: number;
    title: string;
    status: "not-started" | "in-progress" | "completed";
    description?: string;
    owner?: string;
    blockedBy?: number[];
    blocks?: number[];
}
export interface TodosListResult {
    items: TodoItem[];
    summary: {
        total: number;
        completed: number;
        inProgress: number;
        notStarted: number;
    };
}
export interface AgentPingResult {
    status: "ok";
}
export interface MemorySearchParams {
    query: string;
    /** Max results (default 10). */
    limit?: number;
}
export interface MemorySearchResult {
    results: Array<{
        id: string;
        text: string;
        score: number;
        source: string;
        metadata?: Record<string, unknown>;
    }>;
}
export interface MemoryDeleteParams {
    /** Source: "local" only (QMemory delete via adapter). */
    source: "local" | "qmemory";
    /** For local: target ("memory" | "user"). */
    target?: string;
    /** For local: substring to match and remove. For qmemory: memory block ID. */
    match: string;
}
export interface MemoryDeleteResult {
    ok: boolean;
    removedCount: number;
    message: string;
}
export interface TasksListParams {
    /** Filter by lifecycle state. */
    lifecycle?: "running" | "completed" | "failed" | "cancelled" | "all";
}
export interface TasksListResult {
    tasks: Array<{
        taskId: string;
        type: string;
        lifecycle: string;
        label?: string;
    }>;
}
export interface TasksCancelParams {
    taskId: string;
}
export interface TasksCancelResult {
    ok: boolean;
    message: string;
}
export type ProjectType = RpcProjectType;
export type ProjectStatus = RpcProjectStatus;
export type ProjectInfo = RpcProjectInfo;
export type ProjectCreateParams = GatewayRpcMethodMap["project.create"]["params"];
export type ProjectCreateResult = GatewayRpcMethodMap["project.create"]["result"];
export type ProjectListParams = GatewayRpcMethodMap["project.list"]["params"];
export type ProjectListResult = GatewayRpcMethodMap["project.list"]["result"];
export type ProjectDeleteParams = GatewayRpcMethodMap["project.delete"]["params"];
export type ProjectDeleteResult = GatewayRpcMethodMap["project.delete"]["result"];
export type ProjectRenameParams = GatewayRpcMethodMap["project.rename"]["params"];
export type ProjectRenameResult = GatewayRpcMethodMap["project.rename"]["result"];
export type ProjectArchiveParams = GatewayRpcMethodMap["project.archive"]["params"];
export type ProjectArchiveResult = GatewayRpcMethodMap["project.archive"]["result"];
export type ProjectUnarchiveParams = GatewayRpcMethodMap["project.unarchive"]["params"];
export type ProjectUnarchiveResult = GatewayRpcMethodMap["project.unarchive"]["result"];
export type ProjectUpdateParams = GatewayRpcMethodMap["project.update"]["params"];
export type ProjectUpdateResult = GatewayRpcMethodMap["project.update"]["result"];
export type ProjectArchiveByGroupParams = GatewayRpcMethodMap["project.archiveByGroup"]["params"];
export type ProjectArchiveByGroupResult = GatewayRpcMethodMap["project.archiveByGroup"]["result"];
export type SessionCreateParams = GatewayRpcMethodMap["session.create"]["params"];
export type SessionCreateResult = GatewayRpcMethodMap["session.create"]["result"];
export type SessionListParams = GatewayRpcMethodMap["session.list"]["params"];
export type SessionListResult = GatewayRpcMethodMap["session.list"]["result"];
export type SessionGetParams = GatewayRpcMethodMap["session.get"]["params"];
export type SessionGetResult = GatewayRpcMethodMap["session.get"]["result"];
export type SessionUpdateParams = GatewayRpcMethodMap["session.update"]["params"];
export type SessionUpdateResult = GatewayRpcMethodMap["session.update"]["result"];
export type SessionDeleteParams = GatewayRpcMethodMap["session.delete"]["params"];
export type SessionDeleteResult = GatewayRpcMethodMap["session.delete"]["result"];
export type SessionArchiveParams = GatewayRpcMethodMap["session.archive"]["params"];
export type SessionArchiveResult = GatewayRpcMethodMap["session.archive"]["result"];
export type InstructionsListParams = GatewayRpcMethodMap["instructions.list"]["params"];
export type InstructionsListResult = GatewayRpcMethodMap["instructions.list"]["result"];
export type InstructionsReadParams = GatewayRpcMethodMap["instructions.read"]["params"];
export type InstructionsReadResult = GatewayRpcMethodMap["instructions.read"]["result"];
export type InstructionsWriteParams = GatewayRpcMethodMap["instructions.write"]["params"];
export type InstructionsWriteResult = GatewayRpcMethodMap["instructions.write"]["result"];
export type InstructionsDeleteParams = GatewayRpcMethodMap["instructions.delete"]["params"];
export type InstructionsDeleteResult = GatewayRpcMethodMap["instructions.delete"]["result"];
export type FilesListParams = GatewayRpcMethodMap["files.list"]["params"];
export type FilesListResult = GatewayRpcMethodMap["files.list"]["result"];
export type FilesReadParams = GatewayRpcMethodMap["files.read"]["params"];
export type FilesReadResult = GatewayRpcMethodMap["files.read"]["result"];
export type FilesCreateParams = GatewayRpcMethodMap["files.create"]["params"];
export type FilesCreateResult = GatewayRpcMethodMap["files.create"]["result"];
export type FilesRenameParams = GatewayRpcMethodMap["files.rename"]["params"];
export type FilesRenameResult = GatewayRpcMethodMap["files.rename"]["result"];
export type FilesDeleteParams = GatewayRpcMethodMap["files.delete"]["params"];
export type FilesDeleteResult = GatewayRpcMethodMap["files.delete"]["result"];
export type FilesGitStatusParams = GatewayRpcMethodMap["files.gitStatus"]["params"];
export type FilesGitStatusResult = GatewayRpcMethodMap["files.gitStatus"]["result"];
export type SessionSwitchProjectParams = GatewayRpcMethodMap["session.switchProject"]["params"];
export type SessionSwitchProjectResult = GatewayRpcMethodMap["session.switchProject"]["result"];
export type SessionGetStateParams = GatewayRpcMethodMap["session.getState"]["params"];
export type SessionGetStateResult = GatewayRpcMethodMap["session.getState"]["result"];
export interface RpcMethodMap {
    "initialize": {
        params: InitializeParams;
        result: InitializeResult;
    };
    "thread.create": {
        params: ThreadCreateParams;
        result: ThreadCreateResult;
    };
    "thread.list": {
        params: ThreadListParams;
        result: ThreadListResult;
    };
    "session.resume": {
        params: SessionResumeParams;
        result: SessionResumeResult;
    };
    "session.getInfo": {
        params: SessionGetInfoParams;
        result: SessionGetInfoResult;
    };
    "session.getMessages": {
        params: SessionGetMessagesParams;
        result: SessionGetMessagesResult;
    };
    "memory.list": {
        params: MemoryListParams;
        result: MemoryListResult;
    };
    "memory.read": {
        params: MemoryReadParams;
        result: MemoryReadResult;
    };
    "memory.write": {
        params: MemoryWriteParams;
        result: MemoryWriteResult;
    };
    "memory.search": {
        params: MemorySearchParams;
        result: MemorySearchResult;
    };
    "memory.delete": {
        params: MemoryDeleteParams;
        result: MemoryDeleteResult;
    };
    "memory.dream": {
        params: MemoryDreamParams;
        result: MemoryDreamResult;
    };
    "tools.list": {
        params: ToolsListParams;
        result: ToolsListResult;
    };
    "media.listModels": {
        params: MediaListModelsParams;
        result: MediaListModelsResult;
    };
    "config.get": {
        params: ConfigGetParams;
        result: ConfigGetResult;
    };
    "config.update": {
        params: ConfigUpdateParams;
        result: ConfigUpdateResult;
    };
    "community.getConsent": {
        params: undefined;
        result: CommunityGetConsentResult;
    };
    "community.setConsent": {
        params: CommunitySetConsentParams;
        result: CommunitySetConsentResult;
    };
    "community.matchRegistry": {
        params: CommunityMatchRegistryParams;
        result: CommunityMatchRegistryResult;
    };
    "community.listShared": {
        params: undefined;
        result: CommunityListSharedResult;
    };
    "community.withdrawShared": {
        params: CommunityWithdrawSharedParams;
        result: CommunityWithdrawSharedResult;
    };
    "community.withdrawAllShared": {
        params: CommunityWithdrawAllSharedParams;
        result: CommunityWithdrawAllSharedResult;
    };
    "community.listNotices": {
        params: CommunityListNoticesParams;
        result: CommunityListNoticesResult;
    };
    "community.markNoticeRead": {
        params: CommunityMarkNoticeReadParams;
        result: CommunityMarkNoticeReadResult;
    };
    "community.listPublishAudit": {
        params: CommunityListPublishAuditParams;
        result: CommunityListPublishAuditResult;
    };
    "community.resolveInstall": {
        params: CommunityResolveInstallParams;
        result: CommunityResolveInstallResult;
    };
    "community.installResource": {
        params: CommunityInstallResourceParams;
        result: CommunityInstallResourceResult;
    };
    "community.runtimeStatus": {
        params: CommunityRuntimeStatusParams;
        result: CommunityRuntimeStatusResult;
    };
    "community.installRuntime": {
        params: CommunityInstallRuntimeParams;
        result: CommunityInstallRuntimeResult;
    };
    "community.publishSkill": {
        params: CommunityPublishSkillParams;
        result: CommunityPublishSkillResult;
    };
    "community.publishPet": {
        params: CommunityPublishPetParams;
        result: CommunityPublishPetResult;
    };
    "community.recordSignal": {
        params: CommunityRecordSignalParams;
        result: CommunityRecordSignalResult;
    };
    "community.recordTelemetry": {
        params: CommunityRecordTelemetryParams;
        result: CommunityRecordTelemetryResult;
    };
    "todos.list": {
        params: TodosListParams;
        result: TodosListResult;
    };
    "tasks.list": {
        params: TasksListParams;
        result: TasksListResult;
    };
    "tasks.cancel": {
        params: TasksCancelParams;
        result: TasksCancelResult;
    };
    "agent.ping": {
        params: undefined;
        result: AgentPingResult;
    };
    "agents.scan": {
        params: AgentsScanParams;
        result: AgentDescriptor[];
    };
    "agents.list": {
        params: undefined;
        result: AgentDescriptor[];
    };
    "agents.config": {
        params: AgentsConfigParams;
        result: {
            ok: true;
        };
    };
    "agents.setConfig": {
        params: AgentsSetConfigParams;
        result: {
            ok: true;
        };
    };
    "agents.getConfig": {
        params: AgentsGetConfigParams;
        result: AgentConfig | null;
    };
    "agents.removeConfig": {
        params: AgentsRemoveConfigParams;
        result: {
            ok: true;
        };
    };
    "agents.setGateway": {
        params: AgentsSetGatewayParams;
        result: {
            ok: true;
        };
    };
    "solo.start": {
        params: SoloStartParams;
        result: {
            soloId: string;
        };
    };
    "solo.status": {
        params: SoloIdParams;
        result: SoloStatus | null;
    };
    "solo.cancel": {
        params: SoloIdParams;
        result: {
            ok: true;
        };
    };
    "solo.select": {
        params: SoloSelectParams;
        result: {
            ok: true;
            mergedBranch: string;
        };
    };
    "solo.list": {
        params: undefined;
        result: SoloStatus[];
    };
    "solo.delete": {
        params: SoloDeleteParams;
        result: {
            ok: true;
        };
    };
    "solo.message": {
        params: SoloMessageParams;
        result: {
            resultText: string;
        };
    };
    "solo.evaluate": {
        params: SoloEvaluateParams;
        result: SoloEvaluation;
    };
    "product.plan": {
        params: ProductPlanParams;
        result: {
            productId: string;
            plan: ProductPlan;
        };
    };
    "product.confirm": {
        params: ProductConfirmParams;
        result: {
            productId: string;
            ok: true;
        };
    };
    "product.message": {
        params: ProductMessageParams;
        result: {
            response: string;
            plan?: ProductPlan;
            mutations?: Array<{
                type: string;
                taskId: string;
            }>;
        };
    };
    "product.create": {
        params: ProductCreateParams;
        result: {
            productId: string;
        };
    };
    "product.resume": {
        params: ProductIdParams;
        result: {
            ok: true;
        };
    };
    "product.pause": {
        params: ProductIdParams;
        result: {
            ok: true;
        };
    };
    "product.checkpoint": {
        params: ProductIdParams;
        result: {
            ok: true;
        };
    };
    "product.status": {
        params: ProductIdParams;
        result: ProductStatus | null;
    };
    "product.list": {
        params: undefined;
        result: ProductSummary[];
    };
    "product.delete": {
        params: ProductDeleteParams;
        result: {
            ok: true;
        };
    };
    "product.cancel": {
        params: ProductIdParams;
        result: {
            ok: true;
        };
    };
    "product.rollback": {
        params: ProductIdParams & {
            checkpoint?: string;
        };
        result: {
            ok: true;
        };
    };
    "project.create": {
        params: ProjectCreateParams;
        result: ProjectCreateResult;
    };
    "project.list": {
        params: ProjectListParams;
        result: ProjectListResult;
    };
    "project.delete": {
        params: ProjectDeleteParams;
        result: ProjectDeleteResult;
    };
    "project.rename": {
        params: ProjectRenameParams;
        result: ProjectRenameResult;
    };
    "project.archive": {
        params: ProjectArchiveParams;
        result: ProjectArchiveResult;
    };
    "project.unarchive": {
        params: ProjectUnarchiveParams;
        result: ProjectUnarchiveResult;
    };
    "project.update": {
        params: ProjectUpdateParams;
        result: ProjectUpdateResult;
    };
    "project.archiveByGroup": {
        params: ProjectArchiveByGroupParams;
        result: ProjectArchiveByGroupResult;
    };
    "session.switchProject": {
        params: SessionSwitchProjectParams;
        result: SessionSwitchProjectResult;
    };
    "session.getState": {
        params: SessionGetStateParams;
        result: SessionGetStateResult;
    };
    "session.create": {
        params: SessionCreateParams;
        result: SessionCreateResult;
    };
    "session.list": {
        params: SessionListParams;
        result: SessionListResult;
    };
    "session.get": {
        params: SessionGetParams;
        result: SessionGetResult;
    };
    "session.update": {
        params: SessionUpdateParams;
        result: SessionUpdateResult;
    };
    "session.delete": {
        params: SessionDeleteParams;
        result: SessionDeleteResult;
    };
    "session.archive": {
        params: SessionArchiveParams;
        result: SessionArchiveResult;
    };
    "instructions.list": {
        params: InstructionsListParams;
        result: InstructionsListResult;
    };
    "instructions.read": {
        params: InstructionsReadParams;
        result: InstructionsReadResult;
    };
    "instructions.write": {
        params: InstructionsWriteParams;
        result: InstructionsWriteResult;
    };
    "instructions.delete": {
        params: InstructionsDeleteParams;
        result: InstructionsDeleteResult;
    };
    "files.list": {
        params: FilesListParams;
        result: FilesListResult;
    };
    "files.read": {
        params: FilesReadParams;
        result: FilesReadResult;
    };
    "files.create": {
        params: FilesCreateParams;
        result: FilesCreateResult;
    };
    "files.rename": {
        params: FilesRenameParams;
        result: FilesRenameResult;
    };
    "files.delete": {
        params: FilesDeleteParams;
        result: FilesDeleteResult;
    };
    "files.gitStatus": {
        params: FilesGitStatusParams;
        result: FilesGitStatusResult;
    };
    "settings.listProviders": {
        params: undefined;
        result: SettingsListProvidersResult;
    };
    "settings.addKey": {
        params: SettingsAddKeyParams;
        result: SettingsAddKeyResult;
    };
    "settings.removeKey": {
        params: SettingsRemoveKeyParams;
        result: {
            ok: true;
        };
    };
    "settings.getKey": {
        params: SettingsGetKeyParams;
        result: SettingsGetKeyResult;
    };
    "settings.toggleKey": {
        params: SettingsToggleKeyParams;
        result: {
            ok: true;
        };
    };
    "settings.listModels": {
        params: SettingsListModelsParams;
        result: SettingsListModelsResult;
    };
    "settings.setActiveModel": {
        params: SettingsSetActiveModelParams;
        result: {
            ok: true;
        };
    };
    "settings.getActiveModel": {
        params: SettingsGetActiveModelParams;
        result: SettingsGetActiveModelResult;
    };
    "settings.getOverview": {
        params: undefined;
        result: SettingsGetOverviewResult;
    };
    "settings.refreshModels": {
        params: undefined;
        result: {
            ok: true;
            catalogRefreshed?: boolean;
        };
    };
    "settings.validateKey": {
        params: SettingsValidateKeyParams;
        result: SettingsValidateKeyResult;
    };
}
/** All known RPC method names. */
export type RpcMethod = keyof RpcMethodMap;
/** All RPC method names as a runtime array (for capabilities declaration). */
export declare const ALL_RPC_METHODS: RpcMethod[];
