/**
 * Agent Notification Payload Types — wire-format contract for all JSON-RPC notifications.
 *
 * These types define the exact shape of `params` in every notification the agent emits.
 * Consumers (openclaw UI, Hub relay, Electron, test harness) import from here
 * to get type-safe access to event payloads without depending on agent internals.
 *
 * Design: Agent's protocol/notifications.ts re-exports these; adding a new event =
 * 1. Add payload interface here
 * 2. Add entry in NotificationMethodMap here
 * 3. Add event name string in agent-events.ts (if WS-relayed)
 */
import type { ToolRiskLevel } from "./web-capability.js";
/** Identifies which agent produced this notification (main or teammate). */
export interface AgentSource {
    id: string;
    name: string;
    role: "main" | "teammate";
}
/** Token usage as sent on the wire (JSON-RPC notifications). */
export interface WireTokenUsage {
    inputTokens: number;
    outputTokens: number;
    reasoningTokens?: number;
    cacheRead?: number;
    cacheWrite?: number;
}
/** Embedded thread item for clients using the Thread protocol. */
export interface NotificationThreadItem {
    id: string;
    type: string;
    role: "user" | "assistant" | "system";
    text?: string;
    toolName?: string;
    toolCallId?: string;
    arguments?: string;
    output?: string;
    approved?: boolean;
    strategy?: string;
    createdAt: string;
}
export type MediaResultType = "image" | "tts" | "video" | "music" | "3d";
export type ArtifactType = "code" | "file" | "image" | "document" | "diagram" | "table";
/** Turn started — always emitted first. */
export interface TurnStartNotification {
    turnId: string;
    model?: string;
    provider?: string;
    /** Project that owns this session — enables frontend to associate without fallback guessing */
    projectId?: string;
}
/** Streaming text chunk from the main agent. */
export interface TurnDeltaNotification {
    turnId: string;
    text: string;
    item?: NotificationThreadItem;
    agentSource?: AgentSource;
}
/** Turn completed successfully. */
export interface TurnEndNotification {
    turnId: string;
    content: string;
    usage?: WireTokenUsage;
    model?: string;
    provider?: string;
    item?: NotificationThreadItem;
    agentSource?: AgentSource;
}
/** Turn failed. */
export interface TurnErrorNotification {
    turnId: string;
    error: {
        message: string;
        code?: string;
    };
}
/** Agent self-recovered from an error. */
export interface TurnRecoveryNotification {
    turnId: string;
    action: string;
    detail?: string;
    item?: NotificationThreadItem;
}
/** Tool invocation started. */
export interface TurnToolCallNotification {
    turnId: string;
    callId: string;
    name: string;
    arguments?: string;
    inputSummary?: string;
    item?: NotificationThreadItem;
    agentSource?: AgentSource;
}
/** Tool execution completed. */
export interface TurnToolResultNotification {
    turnId: string;
    callId: string;
    name: string;
    ok: boolean;
    error?: string;
    outputPreview?: string;
    durationMs?: number;
    exitCode?: number;
    stdout?: string;
    stderr?: string;
    details?: Record<string, unknown>;
    item?: NotificationThreadItem;
}
/** Tool execution blocked by permission system. */
export interface TurnToolBlockedNotification {
    turnId: string;
    callId: string;
    name: string;
    reason: string;
    item?: NotificationThreadItem;
}
/** Reasoning/thinking token stream. */
export interface TurnReasoningDeltaNotification {
    turnId: string;
    delta?: string;
    /** Alias for delta — used by stdio-server event forwarding. */
    text?: string;
}
/** Plan/strategy update. */
export interface TurnPlanUpdateNotification {
    turnId: string;
    slug: string;
    content: string;
    item?: NotificationThreadItem;
}
/** Suggestion items. */
export interface TurnSuggestionsNotification {
    turnId: string;
    items: Array<{
        text: string;
        icon?: string;
        action?: string;
    }>;
}
/** Sidechain started execution. */
export interface TurnSidechainStartedNotification {
    turnId: string;
    depth: number;
    role: string;
}
/** Sub-agent streaming text chunk. */
export interface TurnSubagentDeltaNotification {
    agentType: string;
    subagentId?: string;
    text: string;
}
/** Sidechain completed execution. */
export interface TurnSidechainCompletedNotification {
    turnId: string;
    depth: number;
    toolCallCount: number;
}
/** URL / file citations returned by OpenAI built-in tools. */
export interface TurnAnnotationsNotification {
    turnId: string;
    annotations: Array<{
        type: string;
        url?: string;
        title?: string;
        [key: string]: unknown;
    }>;
}
/** Structured media generation result. */
export interface TurnMediaResultNotification {
    turnId: string;
    mediaType: MediaResultType;
    url: string;
    model?: string;
    provider?: string;
    durationSeconds?: number;
    width?: number;
    height?: number;
    mimeType?: string;
    billingUnit?: string;
    billingQuantity?: number;
    taskId?: string;
}
/** Async media generation progress. */
export interface TurnMediaProgressNotification {
    turnId: string;
    taskId: string;
    mediaType: MediaResultType;
    percent: number;
    status: string;
    provider?: string;
}
/** Structured media provider usage for non-token billed image/video/audio calls. */
export interface TurnMediaUsageNotification {
    usageId: string;
    turnId: string;
    mediaType: MediaResultType | string;
    provider: string;
    model: string;
    billingUnit: string;
    billingQuantity: number;
}
/** Capability preflight decision for media requests. */
export interface TurnMediaCapabilityCheckNotification {
    turnId: string;
    mediaType: MediaResultType | string;
    provider: string;
    model: string;
    mode: string;
    allowed: boolean;
    reason?: string;
    capabilities: {
        modes: string[];
        source: string;
        limits: Record<string, unknown>;
        features: Record<string, unknown>;
    };
}
/** Media files auto-downloaded to local storage. */
export interface TurnMediaPersistedNotification {
    turnId: string;
    files: Array<{
        remoteUrl: string;
        localPath: string;
        bytes: number;
        mimeType: string;
    }>;
}
/** Task state change. */
export interface TurnTaskUpdatedNotification {
    turnId: string;
    tasks: Array<{
        id: string;
        title: string;
        status: string;
    }>;
}
/** Real-time todo list update. */
export interface TurnTodosUpdatedNotification {
    turnId: string;
    items: Array<{
        id: number;
        title: string;
        status: string;
        owner?: string;
        blockedBy?: number[];
    }>;
    summary?: {
        total: number;
        completed: number;
        inProgress: number;
        notStarted: number;
    };
}
/** Long-running command execution progress. */
export interface TurnExecProgressNotification {
    output: string;
    elapsedTimeSeconds: number;
    totalLines: number;
    totalBytes: number;
}
/** Generic progress heartbeat. */
export interface TurnHeartbeatNotification {
    turnId: string;
    message: string;
}
/** Human-readable summary of a tool use batch. */
export interface TurnToolUseSummaryNotification {
    turnId: string;
    summary: string;
}
/** Structured artifact produced by the agent. */
export interface TurnArtifactNotification {
    turnId: string;
    artifactId: string;
    type: ArtifactType;
    title: string;
    filePath?: string;
    language?: string;
    content?: string;
    mimeType?: string;
}
/** Agent requests user approval before executing a restricted tool. */
export interface ToolApprovalRequestNotification {
    approvalId: string;
    callId: string;
    toolName: string;
    arguments: string;
    message?: string;
    suggestions?: string[];
    category?: "cross_workspace" | "high_risk_delete" | "high_risk_egress" | "destructive";
    reason?: string;
    options?: Array<{
        optionId: string;
        name: string;
        kind: string;
        scope?: string;
    }>;
    rememberScope?: {
        kind: "directory";
        path: string;
    };
}
/** Skill instruction directive. */
export interface TurnSkillInstructionNotification {
    turnId: string;
    instruction: unknown;
}
/** Agent detected a repeating pattern that should be acquired as a skill from hub. */
export interface TurnSkillAcquisitionNeededNotification {
    turnId: string;
    pattern: {
        suggestedName: string;
        description: string;
        tools: string[];
    };
}
/** Agent asks the user a clarifying question mid-turn. */
export interface TurnAskUserNotification {
    askId?: string;
    requestId?: string;
    questions: Array<{
        header: string;
        question: string;
        options?: Array<{
            label: string;
            description?: string;
        }>;
    }>;
}
/** Memory content changed (local md or QMemory). */
export interface MemoryUpdatedNotification {
    source: string;
    target?: string;
    entryCount?: number;
    summary?: string;
}
/** Skills list changed (activated/deactivated/learned/deleted). */
export interface SkillsUpdatedNotification {
    action: "activate" | "deactivate" | "delete" | "learn" | "promote";
    name?: string;
}
/** Importance decay completed after Dream consolidation. */
export interface MemoryDecayCompletedNotification {
    decayed: number;
    archived: number;
    durationMs: number;
}
/** Session metadata changed. */
export interface SessionInfoNotification {
    sessionId: string;
    title?: string;
    model?: string;
    provider?: string;
    cwd?: string;
    turnCount?: number;
    pinnedAt?: string;
    projectId?: string;
}
/** Permission rule saved/updated. */
export interface PermissionRuleUpdatedNotification {
    pattern: string;
    behavior: string;
    scope?: "session" | "persistent";
}
/** Forwarded notification from a team member child process. */
export interface TeamMemberNotification {
    memberId: string;
    method: string;
    params: unknown;
}
export interface PongNotification {
}
/** Real-time token usage update. */
export interface TurnUsageUpdateNotification {
    turnId: string;
    usage: WireTokenUsage;
    model?: string;
    sessionCostUSD?: number;
}
/** Agent status change notification. */
export interface AgentsStatusNotification {
    agentId: string;
    status: "available" | "spawning" | "running" | "hang" | "failed" | "unavailable";
    health?: {
        missedBeats: number;
        lastActiveAt: string;
    };
    usage?: {
        inputTokens: number;
        outputTokens: number;
        totalTokens: number;
    };
    error?: {
        phase: string;
        message: string;
        retriesLeft: number;
    };
}
/** Agent error notification. */
export interface AgentsErrorNotification {
    agentId: string;
    phase: "detect" | "spawn" | "handshake" | "runtime" | "shutdown" | "heartbeat";
    error: string;
    retriesLeft: number;
}
/** One-click install progress (state transitions + streamed log lines + final result). */
export interface AgentInstallProgressNotification {
    agentId: string;
    event: {
        type: "state";
        state: "installing" | "verifying" | "installed" | "failed";
    } | {
        type: "log";
        stream: "stdout" | "stderr";
        chunk: string;
    } | {
        type: "done";
        ok: boolean;
        error?: string;
    };
}
/**
 * Live streaming chunk from an EXTERNAL agent's prompt turn (agents.prompt). Echoes the gateway's
 * turn identity (sessionId/turnId/requestId passed in agents.prompt params) so the gateway can
 * re-emit it on the same turn.delta path the main agent uses — no separate frontend handling.
 */
export interface AgentsPromptDeltaNotification {
    agentId: string;
    sessionId?: string;
    turnId?: string;
    requestId?: string;
    text: string;
    /** When true this chunk is the agent's reasoning/thinking (→ turn.reasoning_delta), not reply text. */
    reasoning?: boolean;
}
/**
 * Live tool-call lifecycle from an EXTERNAL agent's prompt turn — same echo-the-turn-identity
 * mechanism as AgentsPromptDeltaNotification, so the gateway re-emits it on the main
 * turn.tool_call / turn.tool_result path and the UI shows external tools running, no extra handling.
 */
export interface AgentsPromptToolNotification {
    agentId: string;
    sessionId?: string;
    turnId?: string;
    requestId?: string;
    event: {
        kind: "call";
        callId: string;
        name: string;
        arguments?: string;
        inputSummary?: string;
    } | {
        kind: "result";
        callId: string;
        name: string;
        ok: boolean;
        outputPreview?: string;
        error?: string;
    };
}
/**
 * Plan/task update from an EXTERNAL agent's prompt turn (ACP plan steps). The gateway maps the
 * steps onto the main turn.task_updated path so the UI shows the agent's plan as a task list.
 */
export interface AgentsPromptPlanNotification {
    agentId: string;
    sessionId?: string;
    turnId?: string;
    requestId?: string;
    steps: Array<{
        content?: string;
        title?: string;
        status?: string;
        priority?: string;
    }>;
}
/**
 * Interactive permission request from an EXTERNAL agent's prompt turn. Echoes the gateway's turn
 * identity so the gateway re-emits it on the main turn.approval_request path → the UI shows an
 * approval card; the user's decision returns via the agents.approvalResponse RPC.
 */
export interface AgentsPromptApprovalNotification {
    agentId: string;
    sessionId?: string;
    turnId?: string;
    requestId?: string;
    approvalId: string;
    callId?: string;
    toolName: string;
    arguments?: string;
    message?: string;
    category?: string;
    options?: Array<{
        optionId: string;
        name?: string;
        kind?: string;
    }>;
}
/** Solo agent progress. */
export interface SoloProgressNotification {
    soloId: string;
    agentId: string;
    state: "pending" | "running" | "completed" | "failed" | "idle";
    progress?: string;
}
/** Solo evaluation completed. */
export interface SoloEvaluationNotification {
    soloId: string;
    winnerId: string;
    reasoning: string;
}
/** Solo agent streaming delta. */
export interface SoloAgentDeltaNotification {
    soloId: string;
    agentId: string;
    text: string;
}
/** Solo agent diff. */
export interface SoloAgentDiffNotification {
    soloId: string;
    agentId: string;
    files: {
        path: string;
        hunks: string;
    }[];
}
/** Solo agent usage. */
export interface SoloAgentUsageNotification {
    soloId: string;
    agentId: string;
    inputTokens: number;
    outputTokens: number;
}
/** Product task started. */
export interface ProductTaskStartedNotification {
    productId: string;
    taskId: string;
    assignee: string;
}
/** Product task completed. */
export interface ProductTaskCompletedNotification {
    productId: string;
    taskId: string;
    result: string;
}
/** Product task failed. */
export interface ProductTaskFailedNotification {
    productId: string;
    taskId: string;
    error: string;
}
/** Product checkpoint saved. */
export interface ProductCheckpointedNotification {
    productId: string;
    timestamp: string;
}
/** Product budget warning (>80%). */
export interface ProductBudgetWarningNotification {
    productId: string;
    usedTokens: number;
    maxTotalTokens: number;
    percentage: number;
}
/** Product completed (all tasks done or terminal). */
export interface ProductCompletedNotification {
    productId: string;
    summary: string;
}
/** Product DAG topology. */
export interface ProductDagTopologyNotification {
    productId: string;
    nodes: {
        id: string;
        label: string;
        deps: string[];
    }[];
    edges: {
        from: string;
        to: string;
    }[];
}
/** Product budget update. */
export interface ProductBudgetUpdateNotification {
    productId: string;
    inputTokens: number;
    outputTokens: number;
    elapsed: number;
    maxTotalTokens?: number;
}
/** Product task output delta. */
export interface ProductTaskOutputDeltaNotification {
    productId: string;
    taskId: string;
    text: string;
}
/** Leader agent produced a structured plan — client should present to user. */
export interface ProductPlanReadyNotification {
    productId: string;
    plan: {
        name: string;
        modules: Array<{
            name: string;
            description: string;
            suggestedAgentId?: string;
        }>;
        instances: Array<{
            name: string;
            agentId: string;
            role: string;
        }>;
        tasks: Array<{
            taskId: string;
            assignee: string;
            prompt: string;
            dependsOn?: string[];
        }>;
        reasoning: string;
    };
}
/** Planning failed. */
export interface ProductPlanFailedNotification {
    productId: string;
    error: string;
}
/** Streaming text output from leader during planning. */
export interface ProductPlanningDeltaNotification {
    productId: string;
    text: string;
}
/** Plan interrupted. */
export interface PlanInterruptedNotification {
    planId: string;
    /** The project type (solo/product) of the interrupted plan */
    projectType: "solo" | "product";
    reason: string;
}
/** A project was created. */
export interface ProjectCreatedNotification {
    id: string;
    name: string;
    workspaceDir: string;
    type: string;
    groupId?: string;
}
/** Active project was switched. */
export interface ProjectSwitchedNotification {
    id: string;
    name: string;
    workspaceDir: string;
}
/** A project was deleted. */
export interface ProjectDeletedNotification {
    id: string;
}
/** A project was renamed. */
export interface ProjectRenamedNotification {
    id: string;
    name: string;
    workspaceDir: string;
}
/** A project was archived. */
export interface ProjectArchivedNotification {
    id: string;
}
/** A project was unarchived (restored). */
export interface ProjectUnarchivedNotification {
    id: string;
    name: string;
    workspaceDir: string;
}
/** A sub-agent was spawned. */
export interface TurnSubagentStartedNotification {
    turnId: string;
    subagentId: string;
    agentType: string;
    prompt?: string;
}
/** A sub-agent finished. */
export interface TurnSubagentEndedNotification {
    turnId: string;
    subagentId: string;
    agentType: string;
    ok: boolean;
    outputPreview?: string;
    error?: string;
}
/** A task lifecycle state changed. */
export interface TaskUpdatedNotification {
    taskId: string;
    type: string;
    lifecycle: string;
    label?: string;
}
/** Team member state changed (idle/busy/error/exited). */
export interface TeamMemberStateNotification {
    memberId: string;
    state: string;
}
/** Team created/destroyed. */
export interface TeamUpdatedNotification {
    teamName: string;
    action: string;
    members: Array<{
        agentName: string;
        role: string;
        worktreePath?: string;
        pid?: number;
    }>;
}
/** Emitted when pet soul is hatched/ready. */
export interface PetSoulReadyNotification {
    name: string;
    species: string;
    personality: string;
    catchphrase: string;
    stats: {
        grip: number;
        patience: number;
        curiosity: number;
        appetite: number;
        humor: number;
    };
    rarity: string;
    breed?: string;
    breedColors?: {
        primary: string;
        secondary: string;
    };
}
/** Emitted with a reaction text for the pet speech bubble. */
export interface PetReactionNotification {
    text: string;
    style: "normal" | "thinking" | "excited" | "sleepy";
    duration?: number;
}
/** Emitted when pet gains XP or levels up. */
export interface PetGrowthNotification {
    level: number;
    experience: number;
    xpNeeded?: number;
    displayTraits?: Array<{
        id: string;
        level: number;
    }>;
    nextDisplayTrait?: {
        id: string;
        level: number;
    };
}
/** Emitted to override pet state from agent side. */
export interface PetStateNotification {
    state: string;
}
/** Emitted when agent needs user confirmation for a tool call (design §8 PetConfirmWindow). */
export interface PetConfirmNotification {
    confirmId: string;
    toolName: string;
    description: string;
    risk: ToolRiskLevel;
    timeoutMs?: number;
}
export interface PetAssetUpdatedNotification {
    asset: {
        id: string;
        assetKind: "petdex";
        name: string;
        description: string;
        createdAt: string;
        updatedAt: string;
        atlas: {
            format: "webp";
            columns: 8;
            rows: 9;
            frameCount: 72;
            cellWidth: 192;
            cellHeight: 208;
            width: 1536;
            height: 1872;
            sha256: string;
            imageUrl?: string;
        };
        animations?: Record<string, {
            frames: number[];
            fps: number;
            loop: boolean;
        }>;
        sourcePrompt?: string;
    };
}
export interface SystemActivityNotification {
    category: "dream" | "cron" | "decay" | "system";
    level: "info" | "warn" | "error" | "success";
    title: string;
    detail?: string;
}
export interface WorkflowRecordNotification {
    workflow: {
        id: string;
        name: string;
        active: boolean;
        concurrency: string;
        rev: number;
        createdAt: string;
        updatedAt: string;
        trigger?: unknown;
        def: unknown;
    };
}
export interface WorkflowDeletedNotification {
    workflowId: string;
}
export interface WorkflowRunStartedNotification {
    workflowId: string;
    triggerType: string;
}
export interface WorkflowRunCompletedNotification {
    workflowId: string;
    status: "completed" | "paused" | "skipped";
    triggerType: string;
    outcome?: unknown;
}
export interface WorkflowRunFailedNotification {
    workflowId: string;
    triggerType?: string;
    error: string;
    outcome?: unknown;
}
export interface NotificationMethodMap {
    "turn.start": TurnStartNotification;
    "turn.delta": TurnDeltaNotification;
    "turn.end": TurnEndNotification;
    "turn.error": TurnErrorNotification;
    "turn.recovery": TurnRecoveryNotification;
    "turn.tool_call": TurnToolCallNotification;
    "turn.tool_result": TurnToolResultNotification;
    "turn.tool_blocked": TurnToolBlockedNotification;
    "turn.reasoning_delta": TurnReasoningDeltaNotification;
    "turn.plan_update": TurnPlanUpdateNotification;
    "turn.suggestions": TurnSuggestionsNotification;
    "turn.sidechain_started": TurnSidechainStartedNotification;
    "turn.subagent_delta": TurnSubagentDeltaNotification;
    "turn.sidechain_completed": TurnSidechainCompletedNotification;
    "turn.subagent_started": TurnSubagentStartedNotification;
    "turn.subagent_ended": TurnSubagentEndedNotification;
    "turn.annotations": TurnAnnotationsNotification;
    "turn.media_result": TurnMediaResultNotification;
    "turn.media_progress": TurnMediaProgressNotification;
    "turn.media_usage": TurnMediaUsageNotification;
    "turn.media_capability_check": TurnMediaCapabilityCheckNotification;
    "turn.media_persisted": TurnMediaPersistedNotification;
    "turn.task_updated": TurnTaskUpdatedNotification;
    "turn.todos_updated": TurnTodosUpdatedNotification;
    "task.updated": TaskUpdatedNotification;
    "turn.exec_progress": TurnExecProgressNotification;
    "turn.heartbeat": TurnHeartbeatNotification;
    "turn.tool_use_summary": TurnToolUseSummaryNotification;
    "turn.artifact": TurnArtifactNotification;
    "tool.approval.request": ToolApprovalRequestNotification;
    "turn.skill_instruction": TurnSkillInstructionNotification;
    "turn.skill_acquisition_needed": TurnSkillAcquisitionNeededNotification;
    "turn.ask_user": TurnAskUserNotification;
    "memory.updated": MemoryUpdatedNotification;
    "memory.decay.completed": MemoryDecayCompletedNotification;
    "skills.updated": SkillsUpdatedNotification;
    "session.info": SessionInfoNotification;
    "permission.rule_updated": PermissionRuleUpdatedNotification;
    "team.member.notification": TeamMemberNotification;
    "team.member.state": TeamMemberStateNotification;
    "team.updated": TeamUpdatedNotification;
    "turn.usage_update": TurnUsageUpdateNotification;
    "pong": PongNotification;
    "agents.status": AgentsStatusNotification;
    "agents.error": AgentsErrorNotification;
    "agent.install.progress": AgentInstallProgressNotification;
    "agents.prompt.delta": AgentsPromptDeltaNotification;
    "agents.prompt.tool": AgentsPromptToolNotification;
    "agents.prompt.approval": AgentsPromptApprovalNotification;
    "agents.prompt.plan": AgentsPromptPlanNotification;
    "solo.progress": SoloProgressNotification;
    "solo.evaluation": SoloEvaluationNotification;
    "solo.agentDelta": SoloAgentDeltaNotification;
    "solo.agentDiff": SoloAgentDiffNotification;
    "solo.agentUsage": SoloAgentUsageNotification;
    "product.taskStarted": ProductTaskStartedNotification;
    "product.taskCompleted": ProductTaskCompletedNotification;
    "product.taskFailed": ProductTaskFailedNotification;
    "product.checkpointed": ProductCheckpointedNotification;
    "product.budgetWarning": ProductBudgetWarningNotification;
    "product.completed": ProductCompletedNotification;
    "product.dagTopology": ProductDagTopologyNotification;
    "product.budgetUpdate": ProductBudgetUpdateNotification;
    "product.taskOutput": ProductTaskOutputDeltaNotification;
    "product.planReady": ProductPlanReadyNotification;
    "product.planFailed": ProductPlanFailedNotification;
    "product.planningDelta": ProductPlanningDeltaNotification;
    "plan.interrupted": PlanInterruptedNotification;
    "project.created": ProjectCreatedNotification;
    "project.switched": ProjectSwitchedNotification;
    "project.deleted": ProjectDeletedNotification;
    "project.renamed": ProjectRenamedNotification;
    "project.archived": ProjectArchivedNotification;
    "project.unarchived": ProjectUnarchivedNotification;
    "pet.soul_ready": PetSoulReadyNotification;
    "pet.reaction": PetReactionNotification;
    "pet.growth": PetGrowthNotification;
    "pet.state": PetStateNotification;
    "pet.confirm": PetConfirmNotification;
    "pet.asset.updated": PetAssetUpdatedNotification;
    "system.activity": SystemActivityNotification;
    "workflow.created": WorkflowRecordNotification;
    "workflow.updated": WorkflowRecordNotification;
    "workflow.deleted": WorkflowDeletedNotification;
    "workflow.runStarted": WorkflowRunStartedNotification;
    "workflow.runCompleted": WorkflowRunCompletedNotification;
    "workflow.runFailed": WorkflowRunFailedNotification;
}
/** All known notification method names. */
export type NotificationMethod = keyof NotificationMethodMap;
