import { z } from 'zod';
import { Node, Edge } from '@xyflow/react';
import * as react_jsx_runtime from 'react/jsx-runtime';

/**
 * Workflow-specific logging types and utilities
 */

interface WorkflowExecutionContext {
    type: 'workflow';
    contextType: 'workflow-execution';
    executionId: string;
    workflowId: string;
    workflowName?: string;
    organizationId: string;
    executionPath?: string[];
}
interface WorkflowFailureContext {
    type: 'workflow';
    contextType: 'workflow-failure';
    executionId: string;
    workflowId: string;
    error: string;
}
interface StepStartedContext {
    type: 'workflow';
    contextType: 'step-started';
    stepId: string;
    stepStatus: 'started';
    input: unknown;
    startTime: number;
}
interface StepCompletedContext {
    type: 'workflow';
    contextType: 'step-completed';
    stepId: string;
    stepStatus: 'completed';
    output: unknown;
    duration: number;
    isTerminal: boolean;
    startTime: number;
    endTime: number;
}
interface StepFailedContext {
    type: 'workflow';
    contextType: 'step-failed';
    stepId: string;
    stepStatus: 'failed';
    error: string;
    duration: number;
    startTime: number;
    endTime: number;
}
interface ConditionalRouteContext {
    type: 'workflow';
    contextType: 'conditional-route';
    stepId: string;
    target: string;
    error?: string;
}
interface ExecutionPathContext {
    type: 'workflow';
    contextType: 'execution-path';
    executionPath: string[];
}
type WorkflowLogContext = WorkflowExecutionContext | WorkflowFailureContext | StepStartedContext | StepCompletedContext | StepFailedContext | ConditionalRouteContext | ExecutionPathContext;
interface WorkflowLogMessage {
    level: ExecutionLogLevel;
    message: string;
    timestamp: number;
    context?: WorkflowLogContext;
}

/**
 * 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)
 */

/**
 * 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';
/**
 * Base fields shared by all lifecycle events
 */
interface AgentLifecycleEventBase {
    type: 'agent';
    agentId: string;
    lifecycle: AgentLifecycle;
    sessionId?: string;
}
/**
 * Lifecycle started event - emitted when a phase begins
 * REQUIRED: startTime (phase has started, no end yet)
 */
interface AgentLifecycleStartedEvent extends AgentLifecycleEventBase {
    stage: 'started';
    startTime: number;
    iteration?: number;
}
/**
 * Lifecycle completed event - emitted when a phase succeeds
 * REQUIRED: startTime, endTime, duration (phase has finished successfully)
 */
interface AgentLifecycleCompletedEvent extends AgentLifecycleEventBase {
    stage: 'completed';
    startTime: number;
    endTime: number;
    duration: number;
    iteration?: number;
    attempts?: number;
    memorySize?: {
        sessionMemoryKeys: number;
        historyEntries: number;
    };
}
/**
 * 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;
    endTime: number;
    duration: number;
    error: string;
    iteration?: number;
}
/**
 * Union type for all lifecycle events
 * Discriminated by 'stage' field for type narrowing
 */
type AgentLifecycleEvent = AgentLifecycleStartedEvent | AgentLifecycleCompletedEvent | AgentLifecycleFailedEvent;
/**
 * 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';
    eventType: IterationEventType;
    iteration: number;
    sessionId?: string;
    startTime: number;
    endTime: number;
    duration: number;
    output?: string;
    actionType?: string;
    data?: ActionPlaceholderData;
}
/**
 * Tool call event - captures individual tool executions during iterations
 * Provides granular timing for each tool invocation
 */
interface AgentToolCallEvent {
    type: 'agent';
    agentId: string;
    lifecycle: 'iteration';
    eventType: 'tool-call';
    iteration: number;
    sessionId?: string;
    toolName: string;
    startTime: number;
    endTime: number;
    duration: number;
    success: boolean;
    error?: string;
    input?: Record<string, unknown>;
    output?: unknown;
}
/**
 * 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';

type LogContext = WorkflowLogContext | AgentLogContext;
interface ExecutionLogMessage {
    level: ExecutionLogLevel;
    message: string;
    timestamp: number;
    context?: LogContext;
}

/**
 * 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 agent definition (JSON-safe)
 * Result of serializeDefinition(AgentDefinition)
 */
interface SerializedAgentDefinition {
    config: {
        resourceId: string;
        name: string;
        description: string;
        version: string;
        type: 'agent';
        kind: 'orchestrator' | 'specialist' | 'utility' | 'system';
        status: 'dev' | 'prod';
        links?: ResourceLink[];
        category?: ResourceCategory;
        /** 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;
}
/**
 * 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';
        links?: ResourceLink[];
        category?: ResourceCategory;
        /** 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;
}

/**
 * Workflow step state
 * Aggregates step context events with timing and logs
 */
interface StepState {
    stepId: string;
    stepName: string;
    status: 'pending' | 'running' | 'completed' | 'failed';
    startTime?: number;
    endTime?: number;
    duration?: number;
    input?: unknown;
    output?: unknown;
    error?: unknown;
    logs: WorkflowLogMessage[];
}
/**
 * Complete workflow execution data for node visualization
 * Parsed from execution logs
 */
interface WorkflowNodeVisualizerData {
    steps: StepState[];
    totalDuration: number;
    isRunning: boolean;
}
/**
 * Step data extracted from execution logs
 * Used to provide detailed step information in unified graph nodes
 */
interface StepExecutionData {
    /** Final execution status for this step */
    status: 'pending' | 'running' | 'completed' | 'failed';
    /** Step execution duration in milliseconds */
    duration?: number;
    /** Step input data */
    input?: unknown;
    /** Step output data */
    output?: unknown;
    /** Error data if step failed */
    error?: unknown;
    /** Log messages from this step (reserved for future use) */
    logs?: unknown[];
}
/**
 * Execution path tracking state
 *
 * Tracks which steps have been executed and which edges were taken during workflow
 * execution. This state is built from SSE execution log events and used to compute
 * the visual dimming/highlighting of nodes and edges.
 *
 * Algorithm:
 * - `executedSteps` provides O(1) lookup for "has this step been reached?"
 * - `executedStepsOrdered` preserves execution order for edge inference
 * - `takenEdges` comes from `conditional-route` SSE events + linear step inference
 * - `currentStepId` tracks the actively running step for animation
 * - `stepStatusMap` provides final status for each executed step
 * - `stepDataMap` provides detailed execution data (duration, input, output, error)
 */
interface ExecutionPathState {
    /** Set of step IDs that have been executed (O(1) lookup) */
    executedSteps: Set<string>;
    /** Step IDs in execution order (for inferring linear edges) */
    executedStepsOrdered: string[];
    /** Set of edge IDs that were traversed (format: "edge-{source}-{target}") */
    takenEdges: Set<string>;
    /** Currently running step ID (undefined if no step is running) */
    currentStepId?: string;
    /** Map of step IDs to their final execution status */
    stepStatusMap?: Map<string, 'pending' | 'running' | 'completed' | 'failed'>;
    /** Map of step IDs to their execution data (duration, input, output, error) */
    stepDataMap?: Map<string, StepExecutionData>;
}

/**
 * Agent timeline and observability types
 * Used for UI timeline visualization and backend processing
 */

/**
 * Sub-activity within an iteration
 * Represents reasoning, actions, or tool calls with timing
 */
interface SubActivity {
    type: 'reasoning' | 'action' | 'tool-call';
    startTime: number;
    endTime: number;
    duration: number;
    details: AgentIterationEvent | AgentToolCallEvent;
}
/**
 * Agent iteration state
 * Aggregates lifecycle events and sub-activities for a single iteration
 */
interface AgentIteration {
    iterationNumber: number;
    status: 'running' | 'completed' | 'failed' | 'pending';
    iterationEvents: AgentIterationEvent[];
    duration?: number;
    timestamp: number;
    subActivities: SubActivity[];
    startTime?: number;
    endTime?: number;
}
/**
 * Agent lifecycle node state
 * Represents initialization or completion phase
 */
interface AgentLifecycleNode {
    type: 'initialization' | 'completion';
    status: 'running' | 'completed' | 'failed' | 'pending';
    duration?: number;
    timestamp?: number;
    startTime?: number;
    endTime?: number;
}
/**
 * Complete agent execution data for timeline visualization
 * Parsed from execution logs
 */
interface AgentIterationData {
    initialization: AgentLifecycleNode;
    iterations: AgentIteration[];
    completion: AgentLifecycleNode;
    currentIteration: number | null;
    totalIterations: number;
    totalDuration?: number;
    status: 'running' | 'completed' | 'failed' | 'warning';
}

declare const LinkSchema: z.ZodObject<{
    nodeId: z.ZodString;
    kind: z.ZodEnum<{
        affects: "affects";
        actions: "actions";
        effects: "effects";
        links: "links";
        reads: "reads";
        writes: "writes";
        emits: "emits";
        triggers: "triggers";
        uses: "uses";
        approval: "approval";
        contains: "contains";
        references: "references";
        maps_to: "maps_to";
        governs: "governs";
        originates_from: "originates_from";
        applies_to: "applies_to";
        uses_catalog: "uses_catalog";
    }>;
}, z.core.$strip>;
type Link = z.infer<typeof LinkSchema>;

/**
 * Resource Registry type definitions
 */

/**
 * Environment/deployment status for resources
 */
type ResourceStatus = 'dev' | 'prod';

declare const ResourceCategorySchema: z.ZodEnum<{
    diagnostic: "diagnostic";
    production: "production";
    internal: "internal";
    testing: "testing";
}>;
type ResourceCategory = z.infer<typeof ResourceCategorySchema>;
type ResourceLink = Link;

type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'warning';
interface APIExecutionSummary {
    id: string;
    status: ExecutionStatus;
    startTime: number;
    endTime?: number;
    resourceStatus?: ResourceStatus;
}
interface APIExecutionDetail extends APIExecutionSummary {
    executionLogs: ExecutionLogMessage[];
    input?: unknown;
    result?: unknown;
    error?: string;
    resourceStatus: ResourceStatus;
    apiVersion?: string | null;
    resourceVersion?: string | null;
    sdkVersion?: string | null;
    isArchived?: boolean;
    archivedLogCount?: number;
}

/**
 * Merges SSE-streamed logs with fetched execution data for instant log display.
 * Deduplicates by composite key (timestamp + message) to avoid showing the same
 * log twice while preserving distinct logs that share the same millisecond.
 *
 * When no streaming logs exist or all SSE logs are already in the fetched data,
 * returns the fetched execution unchanged for referential stability.
 */
declare function useMergedExecution(fetchedExecution: APIExecutionDetail | undefined, streamingLogs: ExecutionLogMessage[] | undefined): APIExecutionDetail | undefined;

/**
 * Hook to track execution path from execution logs
 *
 * This hook parses execution logs to determine:
 * 1. Which steps have been executed
 * 2. Which edges were taken during execution
 * 3. The current running step
 *
 * Algorithm:
 * - Track executed steps from step-started events
 * - Track taken edges from conditional-route events (explicit routing decisions)
 * - Infer linear edges from step execution order (consecutive steps in linear flow)
 * - Track current step from step-started/completed/failed events
 *
 * Edge ID Format (must match useWorkflowStepsLayout):
 * - Linear: edge-{source}-{target}
 * - Conditional: edge-{source}-{target}
 * - Default: edge-{source}-{target}-default
 *
 * @param executionLogs - Array of execution log messages from SSE
 * @param workflowDefinition - Workflow definition
 * @returns Execution path state or undefined if no logs available
 *
 * @see unified-workflow-graph-design-plan.mdx for algorithm details
 */
declare function useExecutionPath(executionLogs: ExecutionLogMessage[] | undefined, workflowDefinition: SerializedWorkflowDefinition | undefined): ExecutionPathState | undefined;

/**
 * Parse execution logs to extract step states for timeline visualization
 */
declare function useTimelineData(execution: APIExecutionDetail | undefined, resourceDefinition: SerializedWorkflowDefinition): WorkflowNodeVisualizerData | undefined;

declare function useAgentIterationData(execution: APIExecutionDetail | undefined, resourceDefinition: SerializedAgentDefinition): AgentIterationData | null;

/**
 * Timeline Bar Props
 * Represents a single horizontal bar in the timeline
 */
interface TimelineBarProps {
    startTime: number;
    endTime: number;
    executionStart: number;
    executionEnd: number;
    status: ExecutionStatus;
    label?: string;
    onClick?: () => void;
    nodeId?: string | number;
    isSelected?: boolean;
    hasSelection?: boolean;
}
/**
 * Timeline Row Props
 * Represents a row with label + one or more bars
 */
interface TimelineRowProps {
    label: string;
    bars: Array<{
        startTime: number;
        endTime: number;
        status: ExecutionStatus;
        label?: string;
        onClick?: () => void;
        nodeId?: string | number;
    }>;
    executionStart: number;
    executionEnd: number;
    indent?: number;
    selectedNodeId?: string | number | null;
}
/**
 * Timeline Container Props
 * Outer container for the timeline
 */
interface TimelineContainerProps {
    executionStart: number;
    executionEnd: number;
    children: React.ReactNode;
}
/**
 * Graph visualization mode
 *
 * - 'definition': Static view for workflow definition display (no dimming, all nodes visible)
 * - 'execution': Dynamic view with execution state overlay (dimming based on execution path)
 */
type GraphMode = 'definition' | 'execution';
/**
 * Unified node data combining workflow structure and execution state
 */
interface UnifiedWorkflowNodeData {
    id: string;
    name: string;
    description: string;
    isEntryPoint: boolean;
    isEndNode: boolean;
    isConditional: boolean;
    routeCount?: number;
    executionStatus?: 'pending' | 'running' | 'completed' | 'failed';
    duration?: number;
    input?: unknown;
    output?: unknown;
    error?: unknown;
    logs?: WorkflowLogMessage[];
    isExecuted: boolean;
    isDimmed: boolean;
    isSelected?: boolean;
    [key: string]: unknown;
}
/**
 * Unified edge data combining workflow structure and execution state
 */
interface UnifiedWorkflowEdgeData {
    edgeType: 'linear' | 'conditional' | 'default';
    label?: string;
    wasTaken: boolean;
    sourceStatus?: ExecutionStatus;
    targetStatus?: ExecutionStatus;
    isDimmed: boolean;
    isAnimated: boolean;
    [key: string]: unknown;
}
type WorkflowEdgeType = 'linear' | 'conditional' | 'default';
/**
 * Data shape for workflow step nodes (static structure)
 */
interface WorkflowStepNodeData {
    id: string;
    name: string;
    description: string;
    isEntryPoint: boolean;
    isEndNode: boolean;
    isConditional: boolean;
    routeCount?: number;
    [key: string]: unknown;
}
/**
 * Data shape for workflow step edges (static structure)
 */
interface WorkflowStepEdgeData {
    edgeType: WorkflowEdgeType;
    label?: string;
    [key: string]: unknown;
}
/**
 * Agent iteration status type (alias for shared ExecutionStatus)
 */
type AgentStatus = ExecutionStatus;
interface AgentIterationNodeData {
    nodeType: 'initialization' | 'iteration' | 'completion';
    label?: string;
    iterationNumber?: number;
    status: AgentStatus;
    reasoningCount?: number;
    actionCount?: number;
    toolCallCount?: number;
    failedToolCallCount?: number;
    duration?: number;
    isLive: boolean;
}
interface AgentIterationEdgeData {
    sourceStatus: AgentStatus;
    targetStatus: AgentStatus;
}

/**
 * useWorkflowStepsLayout - Hook to convert workflow definition to ReactFlow nodes/edges
 *
 * Uses Dagre for automatic graph layout:
 * - Left-to-right flow (LR)
 * - Minimizes edge crossings
 * - Keeps connected nodes closer together
 */

/**
 * Serialized next config from API
 */
interface SerializedNextConfig {
    type: 'linear' | 'conditional';
    target?: string;
    routes?: Array<{
        target: string;
    }>;
    default?: string;
}
/**
 * Serialized workflow step from API
 */
interface SerializedWorkflowStep {
    id: string;
    name: string;
    description: string;
    next: SerializedNextConfig | null;
}
/**
 * Serialized workflow definition subset needed for layout
 */
interface WorkflowStepsLayoutInput {
    entryPoint: string;
    steps: SerializedWorkflowStep[];
}
/**
 * Hook to convert workflow definition to React Flow nodes and edges with Dagre layout
 *
 * @returns nodes, edges, and calculated graphHeight for dynamic container sizing
 */
declare function useWorkflowStepsLayout(workflow: WorkflowStepsLayoutInput | undefined): {
    nodes: Node<WorkflowStepNodeData>[];
    edges: Edge<WorkflowStepEdgeData>[];
    graphHeight: number;
};

/**
 * useUnifiedWorkflowLayout - Merge Dagre layout with execution state
 *
 * Combines static workflow structure (positioned nodes/edges from Dagre) with
 * real-time execution state (status, dimming, taken paths) to produce unified
 * visualization data for the UnifiedWorkflowGraph component.
 */

/**
 * Hook to merge workflow structure layout with execution state
 */
declare function useUnifiedWorkflowLayout(workflow: WorkflowStepsLayoutInput | undefined, executionPath: ExecutionPathState | undefined, selectedStepId?: string | null, mode?: GraphMode): {
    nodes: Node<UnifiedWorkflowNodeData>[];
    edges: Edge<UnifiedWorkflowEdgeData>[];
    graphHeight: number;
};

/**
 * useReactFlowAgent Hook
 *
 * Converts agent iteration data into ReactFlow nodes and edges for visualization.
 */

declare function useReactFlowAgent(iterationData: AgentIterationData | null, _resourceDefinition: SerializedAgentDefinition | undefined, selectedIterationId: number | 'initialization' | 'completion' | null, liveExecutions: Set<string>, selectedExecutionId?: string): {
    nodes: Node[];
    edges: Edge[];
};

/**
 * Format duration in milliseconds for display
 *
 * @param ms - Duration in milliseconds
 * @returns Formatted duration string (e.g., "150ms", "2.5s")
 */
declare function formatDuration(ms?: number): string;

interface StatusIconColors {
    icon: string;
}
interface GetStatusIconOptions {
    status: ExecutionStatus;
    colors: StatusIconColors;
    iconSize: number;
    spinDuration?: string;
}
/**
 * Get status icon component for execution nodes
 *
 * @param options - Configuration for icon rendering
 * @returns React component for the status icon
 */
declare function getStatusIcon({ status, colors, iconSize, spinDuration }: GetStatusIconOptions): react_jsx_runtime.JSX.Element;

/**
 * Get the color for a resource status badge
 * @param resourceStatus - The resource status ('dev' | 'prod')
 * @returns CSS variable color string
 */
declare function getResourceStatusColor(resourceStatus: ResourceStatus): string;

/**
 * Unified status color system for execution visualizers
 * Shared between workflow and agent implementations
 */

interface StatusColorScheme {
    color: string;
    badge: string;
}
/**
 * Status color mappings using CSS variables for theme-aware colors
 * Simplified: one color for all visual elements (icon, border, selection)
 */
declare const STATUS_COLORS: Record<ExecutionStatus, StatusColorScheme>;
/**
 * Get status colors for a given execution status
 */
declare function getStatusColors(status: ExecutionStatus): StatusColorScheme;

interface EdgeColorOptions {
    selected?: boolean;
    sourceStatus: ExecutionStatus;
}
/**
 * Get edge color based on source node status
 * Simplified: uses unified status color system
 */
declare function getEdgeColor({ selected, sourceStatus }: EdgeColorOptions): string;
interface EdgeOpacityOptions {
    sourceStatus: ExecutionStatus;
}
/**
 * Get edge opacity based on source node status
 */
declare function getEdgeOpacity({ sourceStatus }: EdgeOpacityOptions): number;
/**
 * Check if edge should be animated (when source or target is running)
 */
declare function shouldAnimateEdge(sourceStatus: ExecutionStatus, targetStatus: ExecutionStatus): boolean;

/**
 * Calculate timeline bar position and width as percentages
 *
 * Handles edge cases:
 * - Zero duration executions (instant completion)
 * - Activities that start before execution (data inconsistency)
 * - Activities that extend beyond execution end (data inconsistency)
 * - Zero or near-zero duration activities (enforces minimum visible width)
 *
 * @param startTime - Activity start timestamp (absolute)
 * @param endTime - Activity end timestamp (absolute)
 * @param executionStart - Execution start timestamp (absolute)
 * @param executionEnd - Execution end timestamp (absolute)
 * @returns Object with left and width percentages for bar positioning
 */
declare function calculateBarPosition(startTime: number, endTime: number, executionStart: number, executionEnd: number): {
    left: number;
    width: number;
};

/**
 * Timeline visualization constants
 * Layout and styling constants for timeline components
 */
declare const TIMELINE_CONSTANTS: {
    readonly BAR_HEIGHT: 24;
    readonly ROW_GAP: 8;
    readonly MIN_BAR_WIDTH_PERCENT: 0.5;
    readonly LABEL_WIDTH: 200;
    readonly INDENT_SIZE: 16;
    readonly CONTAINER_PADDING: 16;
    readonly CONTAINER_BORDER_RADIUS: 8;
};
/**
 * Shared visualization constants used by both workflow and agent visualizers
 */
declare const SHARED_VIZ_CONSTANTS: {
    readonly NODE_WIDTH: 160;
    readonly NODE_SPACING: 220;
    readonly HANDLE_SIZE: 8;
    readonly MIN_ZOOM: 0.5;
    readonly MAX_ZOOM: 2;
};
/**
 * Container height constant (used by VisualizerContainer and EmptyVisualizer)
 */
declare const CONTAINER_CONSTANTS: {
    CONTAINER_HEIGHT: number;
};
/**
 * Agent-specific dimension and layout constants
 */
declare const AGENT_CONSTANTS: {
    readonly NODE_HEIGHT: 140;
    readonly CONTAINER_HEIGHT: 430;
    readonly FIT_VIEW_PADDING: 0.2;
    readonly ICON_SIZE: 16;
    readonly STATUS_ICON_SIZE: 16;
    readonly CIRCLE_SIZE: 40;
    readonly PULSE_DURATION: "2s";
    readonly TRANSITION_DURATION: "0.2s";
    readonly NODE_WIDTH: 160;
    readonly NODE_SPACING: 220;
    readonly HANDLE_SIZE: 8;
    readonly MIN_ZOOM: 0.5;
    readonly MAX_ZOOM: 2;
};
declare const WORKFLOW_CONSTANTS: {
    readonly FIT_VIEW_PADDING: 0.4;
    readonly ICON_SIZE: 20;
    readonly CIRCLE_SIZE: 40;
    readonly SPIN_DURATION: "1s";
    readonly NODE_WIDTH: 160;
    readonly NODE_SPACING: 220;
    readonly HANDLE_SIZE: 8;
    readonly MIN_ZOOM: 0.5;
    readonly MAX_ZOOM: 2;
};

export { AGENT_CONSTANTS, CONTAINER_CONSTANTS, SHARED_VIZ_CONSTANTS, STATUS_COLORS, TIMELINE_CONSTANTS, WORKFLOW_CONSTANTS, calculateBarPosition, formatDuration, getEdgeColor, getEdgeOpacity, getResourceStatusColor, getStatusColors, getStatusIcon, shouldAnimateEdge, useAgentIterationData, useExecutionPath, useMergedExecution, useReactFlowAgent, useTimelineData, useUnifiedWorkflowLayout, useWorkflowStepsLayout };
export type { AgentIterationEdgeData, AgentIterationNodeData, AgentStatus, EdgeColorOptions, EdgeOpacityOptions, ExecutionPathState, ExecutionStatus, GraphMode, StatusColorScheme, StatusIconColors, StepExecutionData, TimelineBarProps, TimelineContainerProps, TimelineRowProps, UnifiedWorkflowEdgeData, UnifiedWorkflowNodeData, WorkflowEdgeType, WorkflowStepEdgeData, WorkflowStepNodeData, WorkflowStepsLayoutInput };
