@elevasis/ui 1.0.0

package/dist/hooks/index.d.ts

@@ -0,0 +1,1927 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { z } from 'zod';
+
+/**
+ * Error categories for observability grouping and classification.
+ * Used to categorize errors in the execution_errors table metadata.
+ */
+type ExecutionErrorCategory = 'llm' | 'tool' | 'workflow' | 'agent' | 'validation' | 'system';
+
+/**
+ * Shared form field types for dynamic form generation
+ * Used by: Command Queue, Execution Runner UI, future form-based features
+ */
+/**
+ * Supported form field types for action payloads
+ * Maps to Mantine form components
+ */
+type FormFieldType = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' | 'radio' | 'richtext';
+/**
+ * Form field definition
+ */
+interface FormField {
+    /** Field key in payload object */
+    name: string;
+    /** Field label for UI */
+    label: string;
+    /** Field type (determines UI component) */
+    type: FormFieldType;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Required field */
+    required?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Help text */
+    description?: string;
+    /** Options for select/radio */
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    /** Min/max for number */
+    min?: number;
+    max?: number;
+    /** Path to context value for pre-filling (dot notation, e.g., 'proposal.summary') */
+    defaultValueFromContext?: string;
+}
+/**
+ * Form schema for action payload collection
+ */
+interface FormSchema {
+    /** Form title */
+    title?: string;
+    /** Form description */
+    description?: string;
+    /** Form fields */
+    fields: FormField[];
+}
+
+/**
+ * Serialized Registry Types
+ *
+ * Pre-computed JSON-safe types for API responses and Command View.
+ * Serialization happens once at API startup, enabling instant response times.
+ */
+
+/**
+ * Serialized form field for API responses
+ */
+interface SerializedFormField {
+    name: string;
+    label: string;
+    type: FormFieldType;
+    defaultValue?: unknown;
+    required?: boolean;
+    placeholder?: string;
+    description?: string;
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    min?: number;
+    max?: number;
+}
+/**
+ * Serialized form schema for API responses
+ */
+interface SerializedFormSchema {
+    title?: string;
+    description?: string;
+    fields: SerializedFormField[];
+    layout?: 'vertical' | 'horizontal' | 'grid';
+}
+/**
+ * Serialized execution form schema for API responses
+ */
+interface SerializedExecutionFormSchema extends SerializedFormSchema {
+    fieldMappings?: Record<string, string>;
+    submitButton?: {
+        label?: string;
+        loadingLabel?: string;
+        confirmMessage?: string;
+    };
+}
+/**
+ * Serialized schedule config for API responses
+ */
+interface SerializedScheduleConfig {
+    enabled: boolean;
+    defaultSchedule?: string;
+    allowedPatterns?: string[];
+}
+/**
+ * Serialized webhook config for API responses
+ */
+interface SerializedWebhookConfig {
+    enabled: boolean;
+    payloadSchema?: unknown;
+}
+/**
+ * Serialized execution interface for API responses
+ */
+interface SerializedExecutionInterface {
+    form: SerializedExecutionFormSchema;
+    schedule?: SerializedScheduleConfig;
+    webhook?: SerializedWebhookConfig;
+}
+/**
+ * Serialized agent definition (JSON-safe)
+ * Result of serializeDefinition(AgentDefinition)
+ */
+interface SerializedAgentDefinition {
+    config: {
+        resourceId: string;
+        name: string;
+        description: string;
+        version: string;
+        type: 'agent';
+        status: 'dev' | 'prod';
+        /** Whether this resource is archived and should be excluded from registration and deployment */
+        archived?: boolean;
+        systemPrompt: string;
+        constraints?: {
+            maxIterations?: number;
+            timeout?: number;
+            maxSessionMemoryKeys?: number;
+            maxMemoryTokens?: number;
+        };
+        sessionCapable?: boolean;
+        memoryPreferences?: string;
+    };
+    modelConfig: {
+        provider: string;
+        model: string;
+        apiKey: string;
+        temperature: number;
+        maxOutputTokens: number;
+        topP?: number;
+        modelOptions?: Record<string, unknown>;
+    };
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object;
+        outputSchema?: object;
+    }>;
+    knowledgeMap?: {
+        nodeCount: number;
+        nodes: Array<{
+            id: string;
+            description: string;
+            loaded: boolean;
+            hasPrompt: boolean;
+        }>;
+    };
+    metricsConfig?: object;
+    interface?: SerializedExecutionInterface;
+}
+/**
+ * Serialized workflow definition (JSON-safe)
+ * Result of serializeDefinition(WorkflowDefinition)
+ */
+interface SerializedWorkflowDefinition {
+    config: {
+        resourceId: string;
+        name: string;
+        description: string;
+        version: string;
+        type: 'workflow';
+        status: 'dev' | 'prod';
+        /** Whether this resource is archived and should be excluded from registration and deployment */
+        archived?: boolean;
+    };
+    entryPoint: string;
+    steps: Array<{
+        id: string;
+        name: string;
+        description: string;
+        inputSchema?: object;
+        outputSchema?: object;
+        next: {
+            type: 'linear' | 'conditional';
+            target?: string;
+            routes?: Array<{
+                target: string;
+            }>;
+            default?: string;
+        } | null;
+    }>;
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    metricsConfig?: object;
+    interface?: SerializedExecutionInterface;
+}
+
+/**
+ * Memory type definitions
+ * Types for agent memory management with semantic entry types
+ */
+/**
+ * Semantic memory entry types
+ * Use-case agnostic types that describe the purpose of each entry
+ * Memory types mirror action types for clarity and filtering
+ */
+type MemoryEntryType = 'context' | 'input' | 'reasoning' | 'tool-result' | 'delegation-result' | 'error';
+/**
+ * Memory entry - represents a single entry in agent memory
+ * Stored in agent memory, translated by adapters to vendor-specific formats
+ */
+interface MemoryEntry {
+    type: MemoryEntryType;
+    content: string;
+    timestamp: number;
+    turnNumber: number | null;
+    iterationNumber: number | null;
+}
+/**
+ * Agent memory - Self-orchestrated memory with session + working storage
+ * Agent has full control over what persists, framework handles auto-compaction
+ */
+interface AgentMemory {
+    /**
+     * Session memory - Persists for session/conversation duration
+     * Never auto-trimmed by framework
+     * Agent-managed key-value store for critical information
+     * Agent provides strings, framework wraps in MemoryEntry
+     */
+    sessionMemory: Record<string, MemoryEntry>;
+    /**
+     * Working memory - Execution history
+     * Automatically compacted by framework when needed
+     * Agent doesn't control compaction
+     */
+    history: MemoryEntry[];
+}
+
+/**
+ * Action configuration for HITL tasks
+ * Defines available user actions and their behavior
+ */
+interface ActionConfig {
+    /** Unique action identifier (e.g., 'approve', 'retry', 'escalate') */
+    id: string;
+    /** Display label for UI button */
+    label: string;
+    /** Button variant/style */
+    type: 'primary' | 'secondary' | 'danger' | 'outline';
+    /** Tabler icon name (e.g., 'IconCheck', 'IconRefresh') */
+    icon?: string;
+    /** Button color (Mantine theme colors) */
+    color?: string;
+    /** Button variant (Mantine button variant, e.g., 'light', 'filled', 'outline') */
+    variant?: string;
+    /** Execution target (agent/workflow to invoke) */
+    target?: {
+        resourceType: 'agent' | 'workflow';
+        resourceId: string;
+        /**
+         * Optional session ID for agent continuation.
+         * If provided, invokes a new turn on the existing session instead of standalone execution.
+         * Only valid when resourceType is 'agent'.
+         */
+        sessionId?: string;
+    };
+    /** Form schema for collecting action-specific data */
+    form?: FormSchema;
+    /** Payload template for pre-filling forms */
+    payloadTemplate?: unknown;
+    /** Requires confirmation dialog */
+    requiresConfirmation?: boolean;
+    /** Confirmation message */
+    confirmationMessage?: string;
+    /** Help text / tooltip */
+    description?: string;
+}
+
+/**
+ * Origin resource type - where an execution/task originated from.
+ * Used for audit trails and tracking execution lineage.
+ */
+type OriginResourceType = 'agent' | 'workflow' | 'scheduler' | 'api';
+/**
+ * Origin tracking metadata - who/what created this execution/task.
+ * Used by both TaskScheduler and CommandQueue for complete audit trails.
+ */
+interface OriginTracking {
+    originExecutionId: string;
+    originResourceType: OriginResourceType;
+    originResourceId: string;
+}
+
+/**
+ * Command queue task with flexible action system
+ */
+interface Task extends OriginTracking {
+    id: string;
+    organizationId: string;
+    actions: ActionConfig[];
+    context: unknown;
+    selectedAction?: string;
+    actionPayload?: unknown;
+    description?: string;
+    priority: number;
+    /** Optional checkpoint identifier for grouping related human approval tasks */
+    humanCheckpoint?: string;
+    status: TaskStatus;
+    /**
+     * Target resource tracking — mirrors origin columns.
+     * Set when task is created; patchable to redirect execution to a different resource.
+     */
+    targetResourceId?: string;
+    targetResourceType?: 'agent' | 'workflow';
+    /**
+     * Execution ID for the action that runs AFTER user approval.
+     * NULL until execution starts.
+     *
+     * Naming distinction:
+     * - originExecutionId = Parent execution that CREATED the HITL task
+     * - targetExecutionId = Child execution that RUNS AFTER user approval
+     */
+    targetExecutionId?: string;
+    createdAt: Date;
+    completedAt?: Date;
+    completedBy?: string;
+    expiresAt?: Date;
+    idempotencyKey?: string | null;
+}
+/**
+ * Task status values
+ * - pending: awaiting action
+ * - processing: execution in progress after user approval
+ * - completed: action was taken and execution succeeded
+ * - failed: execution failed, task can be retried
+ * - expired: timed out before action
+ */
+type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'expired';
+/**
+ * Parameters for patching mutable metadata on a task
+ */
+interface PatchTaskParams {
+    humanCheckpoint?: string | null;
+    description?: string;
+    priority?: number;
+    context?: Record<string, unknown>;
+    actions?: unknown[];
+    targetResourceId?: string | null;
+    targetResourceType?: 'agent' | 'workflow' | null;
+    targetExecutionId?: string;
+    status?: 'pending' | 'failed' | 'completed';
+}
+
+/**
+ * Checkpoint list item for sidebar grouping
+ * The id field contains the resourceId of the human checkpoint
+ */
+interface CheckpointListItem {
+    /** Human checkpoint resourceId (or 'ungrouped' for tasks without checkpoint) */
+    id: string;
+    /** Display name (same as id, or "Ungrouped" for null) */
+    name: string;
+    /** Task count for this checkpoint */
+    count: number;
+}
+/**
+ * Status counts for pie chart display
+ */
+interface StatusCounts {
+    pending: number;
+    completed: number;
+    expired: number;
+}
+/**
+ * Priority counts for donut chart display
+ */
+interface PriorityCounts {
+    critical: number;
+    high: number;
+    medium: number;
+    low: number;
+}
+/**
+ * Response from GET /command-queue/checkpoints endpoint
+ */
+interface CheckpointListResponse {
+    checkpoints: CheckpointListItem[];
+    /** Total tasks across all checkpoints */
+    total: number;
+    /** Breakdown by status for donut chart */
+    statusCounts: StatusCounts;
+    /** Breakdown by priority for donut chart */
+    priorityCounts: PriorityCounts;
+}
+
+/**
+ * Target for schedule execution - identifies what resource to execute.
+ * Unlike ExecutionTarget, payload is NOT included here because schedules
+ * store payload in the scheduleConfig (varies per step/item).
+ */
+interface ScheduleTarget {
+    resourceType: 'agent' | 'workflow';
+    resourceId: string;
+}
+/**
+ * Optional origin tracking for schedules.
+ * Unlike OriginTracking (which is required), these fields are all optional
+ * for schedules created directly via API (not triggered by another resource).
+ */
+interface ScheduleOriginTracking {
+    originExecutionId?: string;
+    originResourceType?: OriginResourceType;
+    originResourceId?: string;
+}
+type TaskScheduleConfig = RecurringScheduleConfig | RelativeScheduleConfig | AbsoluteScheduleConfig;
+interface RecurringScheduleConfig {
+    type: 'recurring';
+    cron?: string;
+    interval?: 'daily' | 'weekly' | 'monthly';
+    time?: string;
+    timezone: string;
+    payload: Record<string, unknown>;
+    endAt?: string | null;
+    overduePolicy?: 'skip' | 'execute';
+}
+interface RelativeScheduleConfig {
+    type: 'relative';
+    anchorAt: string;
+    anchorLabel?: string;
+    items: RelativeScheduleItem[];
+    overduePolicy?: 'skip' | 'execute';
+}
+interface RelativeScheduleItem {
+    offset: string;
+    payload: Record<string, unknown>;
+    label?: string;
+}
+interface AbsoluteScheduleConfig {
+    type: 'absolute';
+    items: AbsoluteScheduleItem[];
+    overduePolicy?: 'skip' | 'execute';
+}
+interface AbsoluteScheduleItem {
+    runAt: string;
+    payload: Record<string, unknown>;
+    label?: string;
+}
+interface TaskSchedule extends ScheduleOriginTracking {
+    id: string;
+    organizationId: string;
+    name: string;
+    description?: string;
+    target: ScheduleTarget;
+    scheduleConfig: TaskScheduleConfig;
+    nextRunAt?: Date;
+    currentStep: number;
+    status: 'active' | 'paused' | 'completed' | 'cancelled';
+    lastRunAt?: Date;
+    lastExecutionId?: string;
+    maxRetries: number;
+    idempotencyKey?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+/**
+ * Wire-format DTO for notification API responses.
+ * Dates are ISO 8601 strings (not Date objects like the domain Notification type).
+ * Used by frontend hooks that consume /api/notifications.
+ */
+interface NotificationDTO {
+    id: string;
+    userId: string;
+    organizationId: string;
+    category: string;
+    title: string;
+    message: string;
+    actionUrl: string | null;
+    read: boolean;
+    readAt: string | null;
+    createdAt: string;
+}
+
+/**
+ * Session Data Transfer Object (DTO)
+ * Transform type for API responses (snake_case DB → camelCase frontend)
+ * Used by frontend apps to display session data
+ */
+interface SessionDTO {
+    sessionId: string;
+    resourceId: string;
+    organizationId: string;
+    userId?: string | null;
+    turnCount: number;
+    isEnded: boolean;
+    title?: string | null;
+    memorySnapshot?: AgentMemory;
+    metadata?: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+    endedAt?: Date | null;
+}
+
+/**
+ * Time range selector for dashboard metrics
+ */
+type TimeRange = '1h' | '24h' | '7d' | '30d';
+/**
+ * Execution health metrics response
+ * Success rate, P95 duration, execution counts, and trend data
+ * trendData includes executionCount for throughput visualization (eliminates separate API call)
+ */
+interface ExecutionHealthMetrics {
+    successRate: number;
+    p95Duration: number;
+    totalExecutions: number;
+    trendData: Array<{
+        time: string;
+        rate: number;
+        successCount: number;
+        errorCount: number;
+        warningCount: number;
+        executionCount: number;
+    }>;
+    statusCounts: {
+        success: number;
+        failed: number;
+        pending: number;
+        warning: number;
+    };
+    peakPeriod: string;
+    granularity: 'hour' | 'day';
+}
+/**
+ * Error analysis metrics response
+ * Error categories and top failing resources
+ */
+interface ErrorAnalysisMetrics {
+    totalErrors: number;
+    errorsByCategory: Array<{
+        category: string;
+        count: number;
+        percentage: number;
+    }>;
+    topFailingResources: Array<{
+        resourceId: string;
+        name: string;
+        errorCount: number;
+        failureRate: number;
+    }>;
+}
+/**
+ * Business impact metrics response
+ * ROI, labor savings, and cost analysis
+ */
+interface BusinessImpactMetrics$1 {
+    totalSavingsUsd: number;
+    totalCostUsd: number;
+    netSavingsUsd: number;
+    roi: number;
+}
+/**
+ * Cost breakdown metrics response
+ * Per-resource cost analysis
+ */
+interface CostBreakdownMetrics {
+    resources: Array<{
+        resourceId: string;
+        totalCostUsd: number;
+        executionCount: number;
+        avgCostUsd: number;
+    }>;
+}
+/**
+ * Dashboard metrics response
+ * Aggregates core observability metrics in a single response
+ * Note: Throughput data is now included in executionHealth.trendData.executionCount
+ */
+interface DashboardMetrics {
+    executionHealth: ExecutionHealthMetrics;
+    costBreakdown: CostBreakdownMetrics;
+    businessImpact: BusinessImpactMetrics$1;
+    /** ISO timestamp of the currently active deployment, or null if none */
+    activeDeploymentDate: string | null;
+    /** Deployment version of the active deployment, or null if none */
+    activeDeploymentVersion: string | null;
+}
+/**
+ * Error record for list view (ErrorBreakdownTable)
+ */
+interface ErrorRecord {
+    id: string;
+    timestamp: string;
+    errorType: string;
+    message: string;
+    executionId: string;
+    resourceId: string;
+    resourceName: string;
+    severity: 'critical' | 'warning' | 'info';
+    category: ExecutionErrorCategory;
+    resolved: boolean;
+    resolvedAt: string | null;
+    resolvedBy: string | null;
+}
+/**
+ * Full error detail for modal view (ErrorDetailsModal)
+ */
+interface ErrorDetailFull extends ErrorRecord {
+    stackTrace?: string;
+    retryAttempt?: number;
+    stepName?: string;
+    stepSequence?: number;
+    errorContext?: Record<string, unknown>;
+    executionContext?: Record<string, unknown>;
+}
+/**
+ * Error details API response (paginated)
+ */
+interface ErrorDetailResponse {
+    errors: ErrorRecord[];
+    total: number;
+    page: number;
+    limit: number;
+}
+/**
+ * Error trend data for time-series charts
+ */
+interface ErrorTrend {
+    time: string;
+    errorCount: number;
+    criticalCount: number;
+    warningCount: number;
+    infoCount: number;
+}
+/**
+ * Cost trend data point for time-series charts
+ * Represents a single time bucket (hour or day)
+ */
+interface CostTrendDataPoint {
+    time: string;
+    totalCostUsd: number;
+    executionCount: number;
+    avgCostPerExecution: number;
+}
+/**
+ * Cost trends response (time-series data)
+ */
+interface CostTrendsResponse {
+    trendData: CostTrendDataPoint[];
+    granularity: 'hour' | 'day';
+    totalCostUsd: number;
+    totalExecutions: number;
+}
+/**
+ * Cost summary response with MTD and projections
+ */
+interface CostSummaryResponse {
+    current: {
+        totalCostUsd: number;
+        executionCount: number;
+    };
+    previous: {
+        totalCostUsd: number;
+        executionCount: number;
+    };
+    mtd: {
+        totalCostUsd: number;
+        daysElapsed: number;
+    };
+    projection: {
+        monthlyCostUsd: number;
+        confidence: 'low' | 'medium' | 'high';
+    };
+    trend: {
+        changePercent: number;
+        direction: 'up' | 'down' | 'flat';
+    };
+}
+/**
+ * Cost by model data for model-level breakdown
+ */
+interface CostByModelData {
+    model: string;
+    totalCostUsd: number;
+    callCount: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    avgCostPerCall: number;
+}
+/**
+ * Cost by model response
+ */
+interface CostByModelResponse {
+    models: CostByModelData[];
+    totalCostUsd: number;
+    totalCallCount: number;
+}
+
+/**
+ * Base Execution Engine type definitions
+ * Core types shared across all Execution Engine resources
+ */
+
+/**
+ * NOTE: AIResource interface has been removed and replaced with ResourceDefinition
+ * from registry/types.ts. All resources (executable and non-executable) now extend
+ * the unified ResourceDefinition base interface.
+ *
+ * AgentConfig and WorkflowConfig now extend ResourceDefinition directly.
+ * See packages/core/src/registry/types.ts for the base interface definition.
+ */
+type AIResourceDefinition = SerializedWorkflowDefinition | SerializedAgentDefinition;
+
+/**
+ * Resource Registry type definitions
+ */
+
+/**
+ * Environment/deployment status for resources
+ */
+type ResourceStatus$1 = 'dev' | 'prod';
+/**
+ * All resource types in the platform
+ * Used as the discriminator field in ResourceDefinition
+ */
+type ResourceType$1 = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human';
+/**
+ * Base interface for ALL platform resources
+ * Shared by both executable (agents, workflows) and non-executable (triggers, integrations, etc.) resources
+ */
+interface ResourceDefinition {
+    /** Unique resource identifier */
+    resourceId: string;
+    /** Display name */
+    name: string;
+    /** Purpose and functionality description */
+    description: string;
+    /** Version for change tracking and evolution */
+    version: string;
+    /** Resource type discriminator */
+    type: ResourceType$1;
+    /** Environment/deployment status */
+    status: ResourceStatus$1;
+    /** Domain tags for filtering and organization */
+    domains?: ResourceDomain[];
+    /** Whether the agent supports multi-turn sessions (agents only) */
+    sessionCapable?: boolean;
+    /** Whether the resource is local (monorepo) or remote (externally deployed) */
+    origin?: 'local' | 'remote';
+    /** Whether this resource is archived and should be excluded from registration and deployment */
+    archived?: boolean;
+}
+
+/**
+ * Standard Domain Definitions
+ * Centralized domain constants and definitions for all organization resources.
+ */
+
+declare const DOMAINS: {
+    readonly INBOUND_PIPELINE: "inbound-pipeline";
+    readonly LEAD_GEN_PIPELINE: "lead-gen-pipeline";
+    readonly SUPPORT: "support";
+    readonly CLIENT_SUPPORT: "client-support";
+    readonly DELIVERY: "delivery";
+    readonly OPERATIONS: "operations";
+    readonly FINANCE: "finance";
+    readonly EXECUTIVE: "executive";
+    readonly INSTANTLY: "instantly";
+    readonly TESTING: "testing";
+    readonly INTERNAL: "internal";
+    readonly INTEGRATION: "integration";
+    readonly UTILITY: "utility";
+    readonly DIAGNOSTIC: "diagnostic";
+};
+/**
+ * ResourceDomain - Strongly typed domain identifier
+ * Use this type for all domain references to ensure compile-time validation.
+ */
+type ResourceDomain = (typeof DOMAINS)[keyof typeof DOMAINS];
+
+type ExecutionStatus$1 = 'pending' | 'running' | 'completed' | 'failed' | 'warning';
+
+type ActivityType = 'workflow_execution' | 'agent_run' | 'hitl_action' | 'webhook_received' | 'webhook_executed' | 'webhook_failed' | 'credential_change' | 'api_key_change' | 'deployment_change' | 'membership_change';
+type ActivityStatus = 'success' | 'failure' | 'pending' | 'approved' | 'rejected' | 'completed';
+interface Activity {
+    id: string;
+    organizationId: string;
+    activityType: ActivityType;
+    status: ActivityStatus;
+    title: string;
+    description: string | null;
+    entityType: string;
+    entityId: string;
+    entityName: string | null;
+    metadata: Record<string, unknown> | null;
+    actorId: string | null;
+    actorType: string | null;
+    occurredAt: Date;
+    createdAt: Date;
+}
+
+/**
+ * Execution history item.
+ * Represents a single execution triggered by a schedule.
+ */
+declare const ExecutionHistoryItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        running: "running";
+        cancelled: "cancelled";
+    }>;
+    step: z.ZodNullable<z.ZodNumber>;
+    itemLabel: z.ZodNullable<z.ZodString>;
+    duration: z.ZodNullable<z.ZodNumber>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Execution history response.
+ * Returned by GET /schedules/:id/executions with pagination.
+ */
+declare const ExecutionHistoryResponseSchema: z.ZodObject<{
+    executions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+            cancelled: "cancelled";
+        }>;
+        step: z.ZodNullable<z.ZodNumber>;
+        itemLabel: z.ZodNullable<z.ZodString>;
+        duration: z.ZodNullable<z.ZodNumber>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+type ExecutionHistoryItem = z.infer<typeof ExecutionHistoryItemSchema>;
+type ExecutionHistoryResponse = z.infer<typeof ExecutionHistoryResponseSchema>;
+
+declare function useCommandQueue({ status, limit, offset, humanCheckpoint, timeRange, priorityMin, priorityMax, }?: {
+    status?: TaskStatus;
+    limit?: number;
+    offset?: number;
+    humanCheckpoint?: string;
+    timeRange?: TimeRange;
+    priorityMin?: number;
+    priorityMax?: number;
+}): _tanstack_react_query.UseQueryResult<{
+    createdAt: Date;
+    completedAt: Date | undefined;
+    expiresAt: Date | undefined;
+    id: string;
+    organizationId: string;
+    actions: ActionConfig[];
+    context: unknown;
+    selectedAction?: string;
+    actionPayload?: unknown;
+    description?: string;
+    priority: number;
+    humanCheckpoint?: string;
+    status: TaskStatus;
+    targetResourceId?: string;
+    targetResourceType?: "agent" | "workflow";
+    targetExecutionId?: string;
+    completedBy?: string;
+    idempotencyKey?: string | null;
+    originExecutionId: string;
+    originResourceType: OriginResourceType;
+    originResourceId: string;
+}[], Error>;
+
+interface SubmitActionRequest {
+    taskId: string;
+    actionId: string;
+    payload?: unknown;
+    notes?: string;
+}
+interface OptimisticContext {
+    previousData: Map<readonly unknown[], Task[] | undefined>;
+}
+interface ExecutionErrorDetails {
+    message: string;
+    type: string;
+    severity: 'critical' | 'warning' | 'info';
+    category: 'llm' | 'tool' | 'workflow' | 'agent' | 'validation' | 'system';
+    details?: string;
+}
+interface SubmitActionResponse {
+    task: unknown;
+    execution?: {
+        executionId: string;
+        success: boolean;
+        data?: unknown;
+        error?: ExecutionErrorDetails;
+    };
+}
+declare function useSubmitAction(): _tanstack_react_query.UseMutationResult<SubmitActionResponse, Error, SubmitActionRequest, OptimisticContext>;
+
+declare function useDeleteTask(): _tanstack_react_query.UseMutationResult<void, Error, string, {
+    previousData: Map<readonly unknown[], Task[] | undefined>;
+}>;
+
+interface UseCommandQueueTotalsOptions {
+    timeRange?: TimeRange;
+    priorityMin?: number;
+    priorityMax?: number;
+    /** When set, priorityCounts are scoped to this status only */
+    status?: 'pending' | 'completed' | 'expired';
+}
+/**
+ * Fetches command queue totals and checkpoint groupings
+ *
+ * Returns distinct human checkpoints with task counts and status breakdown.
+ * Used for sidebar grouping and donut charts (true totals, not paginated).
+ */
+declare function useCommandQueueTotals({ timeRange, priorityMin, priorityMax, status }?: UseCommandQueueTotalsOptions): _tanstack_react_query.UseQueryResult<CheckpointListResponse, Error>;
+
+declare function usePatchTask(): _tanstack_react_query.UseMutationResult<Task, Error, {
+    taskId: string;
+    params: PatchTaskParams;
+}, unknown>;
+
+/**
+ * Query key factory for executions TanStack Query hooks.
+ * Uses organization UUID (not name) for cache isolation.
+ */
+declare const executionsKeys: {
+    all: readonly ["executions"];
+    resources: (orgId: string | null) => readonly ["executions", "resources", string | null];
+    resourceDefinition: (orgId: string | null, resourceId: string) => readonly ["executions", "definition", string | null, string];
+    executions: (orgId: string | null, resourceId: string) => readonly ["executions", "list", string | null, string];
+    execution: (orgId: string | null, resourceId: string, executionId: string) => readonly ["executions", "execution", string | null, string, string];
+};
+
+/**
+ * Workflow-specific logging types and utilities
+ */
+
+
+
+// Workflow start/end log context
+interface WorkflowExecutionContext {
+  type: 'workflow'
+  contextType: 'workflow-execution'
+  executionId: string
+  workflowId: string
+  workflowName?: string
+  organizationId: string
+  executionPath?: string[]
+}
+
+// Workflow failure log context
+interface WorkflowFailureContext {
+  type: 'workflow'
+  contextType: 'workflow-failure'
+  executionId: string
+  workflowId: string
+  error: string
+}
+
+// Step started log context
+interface StepStartedContext {
+  type: 'workflow'
+  contextType: 'step-started'
+  stepId: string
+  stepStatus: 'started'
+  input: unknown
+  startTime: number // Explicit start timestamp for timeline
+}
+
+// Step completed log context
+interface StepCompletedContext {
+  type: 'workflow'
+  contextType: 'step-completed'
+  stepId: string
+  stepStatus: 'completed'
+  output: unknown
+  duration: number
+  isTerminal: boolean
+  startTime: number // Explicit start timestamp for timeline
+  endTime: number // Explicit end timestamp for timeline
+}
+
+// Step failed log context
+interface StepFailedContext {
+  type: 'workflow'
+  contextType: 'step-failed'
+  stepId: string
+  stepStatus: 'failed'
+  error: string
+  duration: number
+  startTime: number // Explicit start timestamp for timeline
+  endTime: number // Explicit end timestamp for timeline
+}
+
+// Conditional routing log context
+interface ConditionalRouteContext {
+  type: 'workflow'
+  contextType: 'conditional-route'
+  stepId: string
+  target: string
+  error?: string
+}
+
+// Execution path log context
+interface ExecutionPathContext {
+  type: 'workflow'
+  contextType: 'execution-path'
+  executionPath: string[]
+}
+
+// Union of all workflow log contexts
+type WorkflowLogContext =
+  | WorkflowExecutionContext
+  | WorkflowFailureContext
+  | StepStartedContext
+  | StepCompletedContext
+  | StepFailedContext
+  | ConditionalRouteContext
+  | ExecutionPathContext
+
+/**
+ * Agent-specific logging types
+ * Simplified 2-event model: lifecycle, iteration
+ *
+ * Design Philosophy:
+ * - LIFECYCLE EVENTS: Structural checkpoints (initialization, iteration, completion)
+ * - ITERATION EVENTS: Execution activities (reasoning, actions during iterations)
+ */
+
+
+
+// ============================================================================
+// FORMAL TYPES
+// ============================================================================
+
+/**
+ * Agent lifecycle stages
+ * Universal checkpoints that apply to all agent executions
+ */
+type AgentLifecycle = 'initialization' | 'iteration' | 'completion'
+
+/**
+ * Iteration event types
+ * Activities that occur during agent iterations
+ */
+type IterationEventType = 'reasoning' | 'action' | 'tool-call'
+
+// ============================================================================
+// LIFECYCLE EVENTS (Structural Checkpoints)
+// ============================================================================
+
+/**
+ * Base fields shared by all lifecycle events
+ */
+interface AgentLifecycleEventBase {
+  type: 'agent'
+  agentId: string
+  lifecycle: AgentLifecycle
+  sessionId?: string // Optional: only present when agent runs in session context
+}
+
+/**
+ * Lifecycle started event - emitted when a phase begins
+ * REQUIRED: startTime (phase has started, no end yet)
+ */
+interface AgentLifecycleStartedEvent extends AgentLifecycleEventBase {
+  stage: 'started'
+  startTime: number // REQUIRED: Phase start timestamp
+  iteration?: number // Only for 'iteration' lifecycle
+}
+
+/**
+ * Lifecycle completed event - emitted when a phase succeeds
+ * REQUIRED: startTime, endTime, duration (phase has finished successfully)
+ */
+interface AgentLifecycleCompletedEvent extends AgentLifecycleEventBase {
+  stage: 'completed'
+  startTime: number // REQUIRED: Phase start timestamp
+  endTime: number // REQUIRED: Phase end timestamp
+  duration: number // REQUIRED: Calculated duration (endTime - startTime)
+  iteration?: number // Only for 'iteration' lifecycle
+
+  // Optional fields specific to certain lifecycles
+  attempts?: number // Only for 'completion' lifecycle (tracks output generation attempts: 1 or 2)
+  memorySize?: {
+    sessionMemoryKeys: number
+    historyEntries: number
+  } // Only for 'completion' lifecycle (memory snapshot metadata)
+}
+
+/**
+ * Lifecycle failed event - emitted when a phase fails
+ * REQUIRED: startTime, endTime, duration, error (phase has finished with error)
+ */
+interface AgentLifecycleFailedEvent extends AgentLifecycleEventBase {
+  stage: 'failed'
+  startTime: number // REQUIRED: Phase start timestamp
+  endTime: number // REQUIRED: Phase end timestamp
+  duration: number // REQUIRED: Calculated duration (endTime - startTime)
+  error: string // REQUIRED: Error message
+  iteration?: number // Only for 'iteration' lifecycle
+}
+
+/**
+ * Union type for all lifecycle events
+ * Discriminated by 'stage' field for type narrowing
+ */
+type AgentLifecycleEvent = AgentLifecycleStartedEvent | AgentLifecycleCompletedEvent | AgentLifecycleFailedEvent
+
+// ============================================================================
+// ITERATION EVENTS (Execution Activities)
+// ============================================================================
+
+/**
+ * Placeholder data for MVP
+ * Will be typed per actionType in future
+ */
+interface ActionPlaceholderData {
+  message: string
+}
+
+/**
+ * Iteration event - captures activities during agent iterations
+ * Consolidates reasoning (LLM thought process) and actions (tool use, memory ops, etc.)
+ */
+interface AgentIterationEvent {
+  type: 'agent'
+  agentId: string
+  lifecycle: 'iteration' // Always iteration
+  eventType: IterationEventType
+  iteration: number
+  sessionId?: string // Optional: only present when agent runs in session context
+
+  // Timeline timing fields (v2 - Clean Break)
+  startTime: number // Activity start timestamp
+  endTime: number // Activity end timestamp
+  duration: number // Calculated duration (endTime - startTime)
+
+  // Conditional fields based on eventType
+  output?: string // For reasoning events
+  actionType?: string // For action events (tool-use, delegate, memory-write, etc.)
+  data?: ActionPlaceholderData // For action events
+}
+
+/**
+ * Tool call event - captures individual tool executions during iterations
+ * Provides granular timing for each tool invocation
+ */
+interface AgentToolCallEvent {
+  type: 'agent'
+  agentId: string
+  lifecycle: 'iteration' // Always iteration
+  eventType: 'tool-call' // Specific event type for tool calls
+  iteration: number
+  sessionId?: string // Optional: only present when agent runs in session context
+
+  // Tool identification and timing
+  toolName: string // Tool identifier
+  startTime: number // Tool call start timestamp
+  endTime: number // Tool call end timestamp
+  duration: number // Calculated duration
+
+  // Execution results
+  success: boolean // Whether tool execution succeeded
+  error?: string // Error message if failed
+  input?: Record<string, unknown> // Tool input parameters
+  output?: unknown // Tool output result
+}
+
+// ============================================================================
+// UNION TYPES
+// ============================================================================
+
+/**
+ * Union type for all agent log contexts
+ * 3 event types total (lifecycle, iteration, tool-call)
+ */
+type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent
+
+/**
+ * Base execution logger for Execution Engine
+ */
+type ExecutionLogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+
+// Union type for all contexts
+type LogContext = WorkflowLogContext | AgentLogContext
+
+// Updated interface with consolidated context
+interface ExecutionLogMessage {
+  level: ExecutionLogLevel
+  message: string
+  timestamp: number
+  context?: LogContext
+}
+
+/**
+ * Resource Registry type definitions
+ */
+
+
+
+// ============================================================================
+// Core Resource Type Definitions
+// ============================================================================
+
+/**
+ * Environment/deployment status for resources
+ */
+type ResourceStatus = 'dev' | 'prod'
+
+/**
+ * All resource types in the platform
+ * Used as the discriminator field in ResourceDefinition
+ */
+type ResourceType = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human'
+
+// Execution status type shared between API and UI
+type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'warning'
+
+// API execution types
+interface APIExecutionSummary {
+  id: string
+  status: ExecutionStatus
+  startTime: number
+  endTime?: number
+  resourceStatus?: ResourceStatus // 'dev' | 'prod' - optional for backward compatibility
+}
+
+interface APIExecutionDetail extends APIExecutionSummary {
+  executionLogs: ExecutionLogMessage[]
+  input?: unknown
+  result?: unknown
+  error?: string
+  resourceStatus: ResourceStatus // Required in detail view
+  apiVersion?: string | null
+  resourceVersion?: string | null
+  sdkVersion?: string | null
+}
+
+// API request/response types
+interface APIExecutionListResponse {
+  executions: APIExecutionSummary[]
+}
+
+/**
+ * Fetch the execution list for a given resource.
+ *
+ * resourceStatus and limit are intentionally excluded from the query key so that
+ * SSE invalidations (which target the unfiltered key) bust all filter variants.
+ *
+ * @example
+ * const { data, isLoading } = useExecutions(resourceId)
+ *
+ * @example
+ * // With status filter and limit
+ * const { data } = useExecutions(resourceId, 'running', 20)
+ */
+declare function useExecutions(resourceId: string, resourceStatus?: ResourceStatus | 'all', limit?: number): _tanstack_react_query.UseQueryResult<APIExecutionListResponse, Error>;
+
+/**
+ * Fetch a single execution detail.
+ * Automatically polls every 2 seconds while the execution status is 'running'.
+ *
+ * @example
+ * const { data: execution, isLoading } = useExecution(resourceId, executionId)
+ */
+declare function useExecution(resourceId: string, executionId: string): _tanstack_react_query.UseQueryResult<APIExecutionDetail, Error>;
+
+interface ExecuteAsyncParams {
+    resourceId: string;
+    resourceType: ResourceType;
+    input: unknown;
+}
+interface ExecuteAsyncResult {
+    executionId: string;
+    status: string;
+    resourceId: string;
+}
+/**
+ * Trigger an async execution for a workflow or agent.
+ * Invalidates the executions list on success so the new execution appears immediately.
+ *
+ * @example
+ * const { mutate: execute, isPending } = useExecuteAsync()
+ * execute({ resourceId, resourceType: 'workflow', input: { ... } })
+ */
+declare function useExecuteAsync(): _tanstack_react_query.UseMutationResult<ExecuteAsyncResult, Error, ExecuteAsyncParams, unknown>;
+
+interface RetryExecutionParams {
+    resourceId: string;
+    resourceType: ResourceType;
+    input: unknown;
+}
+/**
+ * Retry a failed execution by re-triggering it async.
+ * Functionally identical to useExecuteAsync but named for intent clarity at call sites.
+ */
+declare function useRetryExecution(): _tanstack_react_query.UseMutationResult<{
+    resourceId: string;
+    executionId: string;
+    status: string;
+}, Error, RetryExecutionParams, unknown>;
+
+interface CancelExecutionParams {
+    resourceId: string;
+    executionId: string;
+}
+interface CancelExecutionResult {
+    cancelled: boolean;
+    method: string;
+    resourceId: string;
+    executionId: string;
+}
+/**
+ * Cancel a running execution.
+ * Invalidates both the execution detail and the executions list on success.
+ *
+ * @example
+ * const { mutate: cancel, isPending } = useCancelExecution()
+ * cancel({ resourceId, executionId })
+ */
+declare function useCancelExecution(): _tanstack_react_query.UseMutationResult<CancelExecutionResult, Error, CancelExecutionParams, unknown>;
+
+interface DeleteExecutionParams {
+    resourceId: string;
+    executionId: string;
+}
+/**
+ * Delete a single execution record.
+ * Removes the execution from cache immediately and invalidates the list.
+ */
+declare function useDeleteExecution(): _tanstack_react_query.UseMutationResult<{
+    resourceId: string;
+    executionId: string;
+}, Error, DeleteExecutionParams, unknown>;
+
+interface BulkDeleteExecutionsParams {
+    resourceId: string;
+    resourceStatus?: ResourceStatus | 'all';
+}
+interface BulkDeleteExecutionsResult {
+    resourceId: string;
+    deletedCount: number;
+    resourceStatus?: ResourceStatus | 'all';
+}
+/**
+ * Bulk delete executions for a resource, optionally filtered by status.
+ */
+declare function useBulkDeleteExecutions(): _tanstack_react_query.UseMutationResult<BulkDeleteExecutionsResult, Error, BulkDeleteExecutionsParams, unknown>;
+
+/**
+ * Fetch all available Execution Engine resources (workflows, agents, pipelines).
+ *
+ * @example
+ * const { data, isLoading } = useResources()
+ * const workflows = data?.workflows ?? []
+ * const agents = data?.agents ?? []
+ */
+declare function useResources(): _tanstack_react_query.UseQueryResult<{
+    workflows: ResourceDefinition[];
+    agents: ResourceDefinition[];
+    pipelines: ResourceDefinition[];
+    total: number;
+}, Error>;
+
+/**
+ * Fetch a resource definition (workflow steps, agent actions, etc.).
+ *
+ * @param resourceId - The resource ID to fetch
+ * @param enabled - Whether the query should execute (default: true)
+ */
+declare function useResourceDefinition(resourceId: string, enabled?: boolean): _tanstack_react_query.UseQueryResult<AIResourceDefinition, Error>;
+
+interface UseActivitiesParams {
+    limit?: number;
+    offset?: number;
+    activityType?: ActivityType;
+    entityType?: string;
+    entityId?: string;
+    startDate?: string;
+    endDate?: string;
+    status?: string;
+    search?: string;
+}
+interface ListActivitiesResponse {
+    activities: Activity[];
+    total: number;
+}
+/**
+ * Fetch activities with filtering and pagination
+ *
+ * @example
+ * // Basic usage - fetch recent activities
+ * const { data, error, isLoading } = useActivities({ limit: 50 })
+ *
+ * @example
+ * // Filtered by type
+ * const { data } = useActivities({
+ *   activityType: 'workflow_execution',
+ *   limit: 20
+ * })
+ *
+ * @example
+ * // Filtered by entity
+ * const { data } = useActivities({
+ *   entityType: 'workflow',
+ *   entityId: 'workflow-123'
+ * })
+ */
+interface ActivityTrendResponse {
+    timestamps: Date[];
+    total: number;
+}
+type UseActivityTrendParams = Omit<UseActivitiesParams, 'limit' | 'offset' | 'search' | 'status'>;
+/**
+ * Fetch activity timestamps for the Activity Trend chart
+ *
+ * Uses /activities/trend endpoint which returns only occurred_at timestamps
+ * up to ANALYTICS_SAFETY_LIMIT (10,000), bypassing the MAX_PAGE_LIMIT cap.
+ * Provides accurate counts for any time range regardless of activity volume.
+ */
+declare function useActivityTrend(params?: UseActivityTrendParams): _tanstack_react_query.UseQueryResult<ActivityTrendResponse, Error>;
+declare function useActivities(params?: UseActivitiesParams): _tanstack_react_query.UseQueryResult<ListActivitiesResponse, Error>;
+
+interface UseExecutionLogsParams {
+    resourceId?: string;
+    status?: ExecutionStatus$1 | 'all';
+    resourceStatus?: 'dev' | 'prod' | 'all';
+    startDate?: number;
+    endDate?: number;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Response type for cross-resource execution list
+ * Matches backend ExecutionLogsPageResponse in apps/api/src/execution-engine/handlers.ts
+ */
+interface ExecutionLogsPageResponse {
+    executions: Array<{
+        id: string;
+        resourceId: string;
+        resourceName: string;
+        resourceType: 'workflow' | 'agent' | 'pipeline';
+        status: ExecutionStatus$1;
+        startTime: number;
+        endTime?: number;
+        duration?: number;
+        resourceStatus: 'dev' | 'prod';
+        resourceVersion?: string | null;
+        apiVersion?: string | null;
+        sdkVersion?: string | null;
+    }>;
+    total: number;
+    hasMore: boolean;
+}
+/**
+ * Fetch execution logs across all resources with filtering and pagination
+ *
+ * @example
+ * // Basic usage - fetch recent executions
+ * const { data, error, isLoading } = useExecutionLogs({ limit: 50 })
+ *
+ * @example
+ * // Filtered by status
+ * const { data } = useExecutionLogs({
+ *   status: 'failed',
+ *   limit: 20
+ * })
+ *
+ * @example
+ * // Filtered by resource and date range
+ * const { data } = useExecutionLogs({
+ *   resourceId: 'workflow-123',
+ *   startDate: Date.now() - 86400000, // Last 24 hours
+ *   endDate: Date.now()
+ * })
+ */
+declare function useExecutionLogs(params?: UseExecutionLogsParams): _tanstack_react_query.UseQueryResult<ExecutionLogsPageResponse, Error>;
+
+interface UseNotificationsOptions {
+    limit?: number;
+    offset?: number;
+}
+declare function useNotifications({ limit, offset }?: UseNotificationsOptions): _tanstack_react_query.UseQueryResult<{
+    notifications: NotificationDTO[];
+    total: number;
+}, Error>;
+
+declare function useCostSummary(timeRange: TimeRange): _tanstack_react_query.UseQueryResult<CostSummaryResponse, Error>;
+
+interface UseExecutionHealthParams {
+    timeRange: TimeRange;
+}
+declare function useExecutionHealth({ timeRange }: UseExecutionHealthParams): _tanstack_react_query.UseQueryResult<DashboardMetrics, Error>;
+
+declare function useMarkAsRead(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
+
+declare function useMarkAllAsRead(): _tanstack_react_query.UseMutationResult<void, Error, void, unknown>;
+
+/**
+ * API-only hook for unread notification count.
+ *
+ * For SSE-enhanced real-time counts, consumers should provide
+ * the count via props (e.g., NotificationBell's `unreadCount` prop).
+ */
+declare function useNotificationCount(): _tanstack_react_query.UseQueryResult<number, Error>;
+
+/**
+ * Query key factories for observability hooks.
+ * Scoped by organizationId for cache isolation between tenants.
+ */
+declare const observabilityKeys: {
+    all: readonly ["observability"];
+    errorAnalysis: (organizationId: string | null, timeRange: string) => readonly ["observability", "error-analysis", string | null, string];
+    errorDetails: (organizationId: string | null, filters: object) => readonly ["observability", "error-details", string | null, object];
+    errorDetail: (organizationId: string | null, executionId: string | null) => readonly ["observability", "error-detail", string | null, string | null];
+    errorTrends: (organizationId: string | null, startDate: string, endDate: string, granularity: string) => readonly ["observability", "error-trends", string | null, string, string, string];
+    errorDistribution: (organizationId: string | null, startDate: string, endDate: string, groupBy: string) => readonly ["observability", "error-distribution", string | null, string, string, string];
+    topFailingResources: (organizationId: string | null, startDate: string, endDate: string, limit: number) => readonly ["observability", "top-failing-resources", string | null, string, string, number];
+    costTrends: (organizationId: string | null, timeRange: string, granularity: string) => readonly ["observability", "cost-trends", string | null, string, string];
+    costByModel: (organizationId: string | null, timeRange: string) => readonly ["observability", "cost-by-model", string | null, string];
+    costBreakdown: (organizationId: string | null, timeRange: string) => readonly ["observability", "cost-breakdown", string | null, string];
+    dashboardMetrics: (organizationId: string | null, timeRange: string) => readonly ["observability", "dashboard-metrics", string | null, string];
+    businessImpact: (organizationId: string | null, timeRange: string) => readonly ["observability", "business-impact", string | null, string];
+};
+
+declare function useErrorAnalysis(timeRange: TimeRange): _tanstack_react_query.UseQueryResult<ErrorAnalysisMetrics, Error>;
+
+interface ErrorFilters {
+    errorType?: string;
+    severity?: 'critical' | 'warning' | 'info';
+    search?: string;
+    startDate?: string;
+    endDate?: string;
+    page?: number;
+    limit?: number;
+    /** When true, show only resolved errors. When false, show only unresolved. Omit to show all. */
+    resolved?: boolean;
+}
+declare function useErrorDetails(filters: ErrorFilters): _tanstack_react_query.UseQueryResult<ErrorDetailResponse, Error>;
+declare function useErrorDetail(executionId: string | null): _tanstack_react_query.UseQueryResult<ErrorDetailFull[] | null, Error>;
+
+interface ErrorTrendsParams {
+    startDate: string;
+    endDate: string;
+    granularity: 'hour' | 'day';
+}
+declare function useErrorTrends({ startDate, endDate, granularity }: ErrorTrendsParams): _tanstack_react_query.UseQueryResult<ErrorTrend[], Error>;
+
+interface ErrorDistributionParams {
+    startDate: string;
+    endDate: string;
+    groupBy: 'errorType' | 'resource' | 'severity';
+}
+interface ErrorDistributionItem {
+    label: string;
+    count: number;
+    percentage: number;
+}
+declare function useErrorDistribution({ startDate, endDate, groupBy }: ErrorDistributionParams): _tanstack_react_query.UseQueryResult<ErrorDistributionItem[], Error>;
+
+interface TopFailingResourcesParams {
+    startDate: string;
+    endDate: string;
+    limit?: number;
+}
+interface FailingResource {
+    resourceId: string;
+    resourceType: string;
+    errorCount: number;
+    failureRate: number;
+}
+declare function useTopFailingResources({ startDate, endDate, limit }: TopFailingResourcesParams): _tanstack_react_query.UseQueryResult<FailingResource[], Error>;
+
+/**
+ * Resolve a single error by ID.
+ */
+declare function useResolveError(): _tanstack_react_query.UseMutationResult<unknown, Error, string, unknown>;
+/**
+ * Unresolve a previously resolved error.
+ */
+declare function useUnresolveError(): _tanstack_react_query.UseMutationResult<unknown, Error, string, unknown>;
+/**
+ * Resolve all errors in the organization.
+ */
+declare function useResolveAllErrors(): _tanstack_react_query.UseMutationResult<unknown, Error, void, unknown>;
+/**
+ * Resolve all errors for a specific execution.
+ */
+declare function useResolveErrorsByExecution(): _tanstack_react_query.UseMutationResult<unknown, Error, string, unknown>;
+
+declare function useCostTrends(timeRange: TimeRange, granularity?: 'hour' | 'day' | 'week'): _tanstack_react_query.UseQueryResult<CostTrendsResponse, Error>;
+
+declare function useCostByModel(timeRange: TimeRange): _tanstack_react_query.UseQueryResult<CostByModelResponse, Error>;
+
+interface CostBreakdownItem {
+    resourceId: string;
+    resourceType: string;
+    model: string;
+    totalCost: number;
+    executionCount: number;
+}
+declare function useCostBreakdown(timeRange: TimeRange): _tanstack_react_query.UseQueryResult<CostBreakdownItem[], Error>;
+
+declare function useDashboardMetrics(timeRange: TimeRange): _tanstack_react_query.UseQueryResult<unknown, Error>;
+
+interface BusinessImpactMetrics {
+    totalExecutions: number;
+    estimatedTimeSavedMinutes: number;
+    estimatedCostSavings: number;
+    automationROI: number;
+}
+declare function useBusinessImpact(timeRange: TimeRange): _tanstack_react_query.UseQueryResult<BusinessImpactMetrics, Error>;
+
+/**
+ * Query key factory for schedule cache management.
+ * Provides type-safe, hierarchical keys for TanStack Query.
+ * Uses organizationId (UUID) for tenant-scoped cache isolation.
+ */
+declare const scheduleKeys: {
+    all: (orgId: string | null) => readonly ["schedules", string | null];
+    lists: (orgId: string | null) => readonly ["schedules", string | null, "list"];
+    list: (orgId: string | null, filters?: ListSchedulesFilters) => readonly ["schedules", string | null, "list", ListSchedulesFilters | undefined];
+    details: (orgId: string | null) => readonly ["schedules", string | null, "detail"];
+    detail: (orgId: string | null, id: string) => readonly ["schedules", string | null, "detail", string];
+    executions: (orgId: string | null, id: string) => readonly ["schedules", string | null, "detail", string, "executions"];
+};
+/**
+ * Filters for list schedules query.
+ * Mirrors ListSchedulesQuery from @repo/core but typed for UI consumption.
+ */
+interface ListSchedulesFilters {
+    status?: 'active' | 'paused' | 'completed' | 'cancelled';
+    targetResourceType?: 'agent' | 'workflow';
+    targetResourceId?: string;
+    limit?: number;
+    offset?: number;
+}
+
+interface CreateScheduleInput {
+    name: string;
+    description?: string;
+    target: {
+        resourceType: 'agent' | 'workflow';
+        resourceId: string;
+    };
+    scheduleConfig: TaskScheduleConfig;
+    maxRetries?: number;
+    idempotencyKey?: string;
+    originExecutionId?: string;
+    originResourceType?: 'agent' | 'workflow' | 'scheduler' | 'api';
+    originResourceId?: string;
+}
+interface UpdateScheduleInput {
+    id: string;
+    name?: string;
+    description?: string | null;
+    scheduleConfig?: TaskScheduleConfig;
+    maxRetries?: number;
+}
+/** List response using domain type for CC compatibility. */
+interface ListSchedulesResponse {
+    schedules: TaskSchedule[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * List schedules with optional filters.
+ *
+ * @param filters - Optional filters for status, target resource, and pagination
+ * @returns TanStack Query result with schedules array and pagination info
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useListSchedules({ status: 'active', limit: 20 })
+ * ```
+ */
+declare function useListSchedules(filters?: ListSchedulesFilters): _tanstack_react_query.UseQueryResult<ListSchedulesResponse, Error>;
+/**
+ * Get a single schedule by ID.
+ *
+ * @param id - Schedule UUID (undefined to disable query)
+ * @returns TanStack Query result with schedule data
+ *
+ * @example
+ * ```tsx
+ * const { data: schedule, isLoading } = useGetSchedule(scheduleId)
+ * ```
+ */
+declare function useGetSchedule(id: string | undefined): _tanstack_react_query.UseQueryResult<TaskSchedule, Error>;
+/**
+ * Get execution history for a schedule.
+ *
+ * @param scheduleId - Schedule UUID (undefined to disable query)
+ * @param options - Pagination options (limit, offset)
+ * @returns TanStack Query result with execution history and pagination info
+ *
+ * @example
+ * ```tsx
+ * const { data } = useGetExecutionHistory(scheduleId, { limit: 10 })
+ * ```
+ */
+declare function useGetExecutionHistory(scheduleId: string | undefined, options?: {
+    limit?: number;
+    offset?: number;
+}): _tanstack_react_query.UseQueryResult<{
+    executions: {
+        id: string;
+        createdAt: string;
+        status: "running" | "completed" | "failed" | "cancelled";
+        step: number | null;
+        itemLabel: string | null;
+        duration: number | null;
+        error: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+/**
+ * Create a new schedule.
+ *
+ * @returns TanStack Mutation for creating schedules
+ *
+ * @example
+ * ```tsx
+ * const createSchedule = useCreateSchedule()
+ *
+ * createSchedule.mutate({
+ *   name: 'Daily Report',
+ *   target: { resourceType: 'workflow', resourceId: 'wf-123' },
+ *   scheduleConfig: { type: 'recurring', cron: '0 9 * * *', timezone: 'UTC', payload: {} }
+ * })
+ * ```
+ */
+declare function useCreateSchedule(): _tanstack_react_query.UseMutationResult<TaskSchedule, Error, CreateScheduleInput, unknown>;
+/**
+ * Update schedule fields (name, description, scheduleConfig, maxRetries).
+ * Only active or paused schedules can be updated.
+ *
+ * @returns TanStack Mutation for updating schedules
+ *
+ * @example
+ * ```tsx
+ * const updateSchedule = useUpdateSchedule()
+ *
+ * updateSchedule.mutate({ id: 'schedule-123', name: 'Updated Name' })
+ * ```
+ */
+declare function useUpdateSchedule(): _tanstack_react_query.UseMutationResult<TaskSchedule, Error, UpdateScheduleInput, unknown>;
+/**
+ * Update anchor datetime for relative schedules.
+ * Only applicable to schedules with type: 'relative'.
+ *
+ * @returns TanStack Mutation for updating schedule anchor
+ *
+ * @example
+ * ```tsx
+ * const updateAnchor = useUpdateAnchor()
+ *
+ * updateAnchor.mutate({ id: 'schedule-123', anchorAt: '2026-02-01T09:00:00Z' })
+ * ```
+ */
+declare function useUpdateAnchor(): _tanstack_react_query.UseMutationResult<TaskSchedule, Error, {
+    id: string;
+    anchorAt: string;
+}, unknown>;
+/**
+ * Pause a schedule.
+ * Paused schedules will not execute until resumed.
+ *
+ * @returns TanStack Mutation for pausing schedules
+ *
+ * @example
+ * ```tsx
+ * const pauseSchedule = usePauseSchedule()
+ * pauseSchedule.mutate('schedule-123')
+ * ```
+ */
+declare function usePauseSchedule(): _tanstack_react_query.UseMutationResult<TaskSchedule, Error, string, unknown>;
+/**
+ * Resume a paused schedule.
+ *
+ * @returns TanStack Mutation for resuming schedules
+ *
+ * @example
+ * ```tsx
+ * const resumeSchedule = useResumeSchedule()
+ * resumeSchedule.mutate('schedule-123')
+ * ```
+ */
+declare function useResumeSchedule(): _tanstack_react_query.UseMutationResult<TaskSchedule, Error, string, unknown>;
+/**
+ * Cancel a schedule permanently (soft delete).
+ * Sets status to 'cancelled' -- schedule remains in DB for history.
+ * Cancelled schedules cannot be resumed.
+ *
+ * @returns TanStack Mutation for cancelling schedules
+ *
+ * @example
+ * ```tsx
+ * const cancelSchedule = useCancelSchedule()
+ * cancelSchedule.mutate('schedule-123')
+ * ```
+ */
+declare function useCancelSchedule(): _tanstack_react_query.UseMutationResult<TaskSchedule, Error, string, unknown>;
+/**
+ * Delete a schedule permanently (hard delete).
+ * Removes schedule from database entirely.
+ *
+ * @returns TanStack Mutation for deleting schedules
+ *
+ * @example
+ * ```tsx
+ * const deleteSchedule = useDeleteSchedule()
+ * deleteSchedule.mutate('schedule-123')
+ * ```
+ */
+declare function useDeleteSchedule(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
+
+interface SessionListItem {
+    sessionId: string;
+    resourceId: string;
+    turnCount: number;
+    isEnded: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateSessionResponse {
+    sessionId: string;
+    resourceId: string;
+    turnCount: number;
+    createdAt: string;
+}
+/**
+ * Response type from the /api/dev/execution-engine/resources endpoint
+ */
+interface ResourcesResponse {
+    workflows: ResourceDefinition[];
+    agents: ResourceDefinition[];
+    pipelines: ResourceDefinition[];
+}
+/**
+ * Operations Service for fetching Execution Engine resources
+ */
+declare class OperationsService {
+    private apiRequest;
+    constructor(apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>);
+    /**
+     * Fetch all available Execution Engine resources
+     * Uses the unified /list-resources endpoint
+     */
+    getResources(): Promise<ResourcesResponse>;
+    /**
+     * Get detailed workflow information
+     * Optional: For future detailed views
+     */
+    getWorkflowDetails(): Promise<ResourceDefinition[]>;
+    /**
+     * Get detailed agent information
+     * Optional: For future detailed views
+     */
+    getAgentDetails(): Promise<ResourceDefinition[]>;
+    /**
+     * Get detailed pipeline information
+     * Optional: For future detailed views
+     */
+    getPipelineDetails(): Promise<ResourceDefinition[]>;
+    /**
+     * Get resource definition (workflow steps, agent actions, pipeline stages, etc.)
+     */
+    getResourceDefinition(resourceId: string): Promise<AIResourceDefinition>;
+    /**
+     * List sessions with optional filtering
+     */
+    listSessions(params?: {
+        resourceId?: string;
+    }): Promise<SessionListItem[]>;
+    /**
+     * Get session details by ID
+     */
+    getSession(sessionId: string): Promise<SessionDTO>;
+    /**
+     * Create a new session for an agent
+     */
+    createSession(resourceId: string): Promise<CreateSessionResponse>;
+    /**
+     * Archive a session
+     */
+    archiveSession(sessionId: string): Promise<void>;
+}
+
+export { OperationsService, executionsKeys, observabilityKeys, scheduleKeys, useActivities, useActivityTrend, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCommandQueue, useCommandQueueTotals, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteTask, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePatchTask, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useSubmitAction, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule };
+export type { ActivityTrendResponse, BulkDeleteExecutionsParams, BulkDeleteExecutionsResult, BusinessImpactMetrics, CancelExecutionParams, CancelExecutionResult, CostBreakdownItem, CreateScheduleInput, CreateSessionResponse, DeleteExecutionParams, ErrorDistributionItem, ErrorDistributionParams, ErrorFilters, ErrorTrendsParams, ExecuteAsyncParams, ExecuteAsyncResult, ExecutionErrorDetails, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogsPageResponse, FailingResource, ListActivitiesResponse, ListSchedulesFilters, ListSchedulesResponse, ResourcesResponse, RetryExecutionParams, SessionListItem, SubmitActionRequest, SubmitActionResponse, TaskSchedule, TopFailingResourcesParams, UpdateScheduleInput, UseActivitiesParams, UseActivityTrendParams, UseExecutionHealthParams, UseExecutionLogsParams };