import { WorkflowEvent } from 'awaitly';
export { ScopeType } from 'awaitly';
import { D as DecisionStartEvent, a as DecisionBranchEvent, b as DecisionEndEvent, S as ScopeStartEvent, c as ScopeEndEvent, W as WorkflowIR, O as OutputFormat, V as VisualizerOptions } from './url-CKfrOJ3y.js';
export { A as ActiveStepSnapshot, B as BaseNode, C as ColorScheme, d as DecisionBranch, e as DecisionEvent, f as DecisionNode, g as DiagramSource, E as EnhancedRenderOptions, h as ExportFormat, i as ExportOptions, F as FlowNode, j as FlowchartRenderOptions, H as HTMLRenderOptions, k as HTMLTheme, l as HeatLevel, m as HeatmapData, n as HookExecution, o as HookState, I as IRSnapshot, K as KrokiExportOptions, p as KrokiFormat, L as LayoutDirection, q as LiveVisualizerOptions, M as MermaidInkExportOptions, r as MermaidRenderOptions, N as NodePerformance, P as ParallelNode, R as RaceNode, s as RenderOptions, t as Renderer, u as ScopeEvent, v as SequenceNode, w as ServerMessage, x as StepNode, y as StepSkippedEvent, z as StepState, G as StreamNode, T as TimeTravelState, U as UrlGeneratorOptions, J as VisualizingWorkflowOptions, Q as WebVisualizerMessage, X as WorkflowHooks, Y as WorkflowNode, Z as createUrlGenerator, _ as hasChildren, $ as isDecisionNode, a0 as isParallelNode, a1 as isRaceNode, a2 as isSequenceNode, a3 as isStepNode, a4 as isStreamNode, a5 as toKrokiPngUrl, a6 as toKrokiSvgUrl, a7 as toKrokiUrl } from './url-CKfrOJ3y.js';
export { D as DecisionTracker, H as HookLog, I as IRBuilderOptions, a as IfTracker, L as LiveVisualizer, b as LoggerOutput, c as LoggerRenderOptions, P as ParallelDetectorOptions, d as PerformanceAnalyzer, S as StepLog, e as SwitchTracker, T as TimeTravelController, f as TimeTravelOptions, W as WorkflowRun, g as WorkflowSummary, h as asciiRenderer, i as createIRBuilder, j as createParallelDetector, k as createPerformanceAnalyzer, l as createTimeTravelController, m as defaultColorScheme, n as detectParallelGroups, o as flowchartRenderer, p as getHeatLevel, q as htmlRenderer, r as loggerRenderer, s as mermaidRenderer, t as renderToHTML, u as trackDecision, v as trackIf, w as trackSwitch } from './performance-analyzer-DC60uCY-.js';
export { D as DiagramProvider, K as KrokiProviderOptions, M as MermaidInkFormat, a as MermaidInkGenerator, b as MermaidInkImageType, c as MermaidInkOptions, d as MermaidInkPaperSize, e as MermaidInkProviderOptions, f as MermaidInkTheme, P as ProviderOptions, g as buildMermaidInkUrl, h as createMermaidInkGenerator, i as encodeForMermaidInk, t as toMermaidInkJpegUrl, j as toMermaidInkPdfUrl, k as toMermaidInkPngUrl, l as toMermaidInkSvgUrl, m as toMermaidInkUrl, n as toMermaidInkWebpUrl } from './types-DjSWix07.js';

/**
 * Browser-safe Workflow Visualization Module
 *
 * Excludes Node.js-specific features:
 * - createLiveVisualizer (requires process.stdout)
 * - fetchKroki* functions (requires Node.js fetch with Buffer)
 *
 * @example
 * ```typescript
 * import { createVisualizer } from 'awaitly-visualizer';
 *
 * const viz = createVisualizer({ workflowName: 'checkout' });
 * const workflow = createWorkflow(deps, { onEvent: viz.handleEvent });
 *
 * await workflow.run(async ({ step }) => {
 *   await step(() => validateCart(cart), 'Validate cart');
 *   await step(() => processPayment(payment), 'Process payment');
 * });
 *
 * console.log(viz.render());
 * ```
 */

/**
 * Creates a live terminal visualizer.
 *
 * @throws Error - Not available in browser environments
 */
declare const createLiveVisualizer: () => never;
/**
 * Workflow visualizer that processes events and renders output.
 */
interface WorkflowVisualizer {
    /** Process a workflow event */
    handleEvent: (event: WorkflowEvent<unknown>) => void;
    /** Process a scope event (parallel/race) */
    handleScopeEvent: (event: ScopeStartEvent | ScopeEndEvent) => void;
    /** Process a decision event (conditional branches) */
    handleDecisionEvent: (event: DecisionStartEvent | DecisionBranchEvent | DecisionEndEvent) => void;
    /** Get current IR state */
    getIR: () => WorkflowIR;
    /** Render current state using the default renderer */
    render: () => string;
    /** Render to a specific format */
    renderAs: (format: OutputFormat) => string;
    /** Reset state for a new workflow */
    reset: () => void;
    /** Subscribe to IR updates (for live visualization) */
    onUpdate: (callback: (ir: WorkflowIR) => void) => () => void;
}
/**
 * Create a workflow visualizer.
 *
 * @example
 * ```typescript
 * const viz = createVisualizer({ workflowName: 'my-workflow' });
 *
 * const workflow = createWorkflow(deps, {
 *   onEvent: viz.handleEvent,
 * });
 *
 * await workflow.run(async ({ step }) => { ... });
 *
 * console.log(viz.render());
 * ```
 */
declare function createVisualizer(options?: VisualizerOptions): WorkflowVisualizer;
/**
 * Combine multiple event handlers into one.
 * Use when you need visualization + logging + custom handlers.
 *
 * @example
 * ```typescript
 * const viz = createVisualizer({ workflowName: 'checkout' });
 * const workflow = createWorkflow(deps, {
 *   onEvent: combineEventHandlers(
 *     viz.handleEvent,
 *     (e) => console.log(e.type),
 *     (e) => metrics.track(e),
 *   ),
 * });
 * ```
 */
declare function combineEventHandlers<E = unknown, C = void>(...handlers: Array<(event: WorkflowEvent<E, C>, ctx?: C) => void>): (event: WorkflowEvent<E, C>, ctx: C) => void;
/**
 * Union type for all collectable/visualizable events (workflow + decision).
 */
type CollectableEvent = WorkflowEvent<unknown> | DecisionStartEvent | DecisionBranchEvent | DecisionEndEvent;
/**
 * Visualize collected events (post-execution).
 *
 * Supports both workflow events (from onEvent) and decision events
 * (from trackDecision/trackIf/trackSwitch).
 *
 * @example
 * ```typescript
 * const events: CollectableEvent[] = [];
 * const workflow = createWorkflow(deps, {
 *   onEvent: (e) => events.push(e),
 * });
 *
 * await workflow.run(async ({ step }) => {
 *   const decision = trackIf('check', condition, {
 *     emit: (e) => events.push(e),
 *   });
 *   // ...
 * });
 *
 * console.log(visualizeEvents(events));
 * ```
 */
declare function visualizeEvents(events: CollectableEvent[], options?: VisualizerOptions): string;
/**
 * Create an event collector for later visualization.
 *
 * Supports both workflow events (from onEvent) and decision events
 * (from trackDecision/trackIf/trackSwitch).
 *
 * @example
 * ```typescript
 * const collector = createEventCollector();
 *
 * const workflow = createWorkflow(deps, {
 *   onEvent: collector.handleEvent,
 * });
 *
 * await workflow.run(async ({ step }) => {
 *   // Decision events can also be collected
 *   const decision = trackIf('check', condition, {
 *     emit: collector.handleDecisionEvent,
 *   });
 *   // ...
 * });
 *
 * console.log(collector.visualize());
 * ```
 */
declare function createEventCollector(options?: VisualizerOptions): {
    /** Handle a workflow event */
    handleEvent: (event: WorkflowEvent<unknown>) => void;
    /** Handle a decision event */
    handleDecisionEvent: (event: DecisionStartEvent | DecisionBranchEvent | DecisionEndEvent) => void;
    /** Get all collected events */
    getEvents: () => CollectableEvent[];
    /** Get workflow events only */
    getWorkflowEvents: () => WorkflowEvent<unknown>[];
    /** Get decision events only */
    getDecisionEvents: () => (DecisionStartEvent | DecisionBranchEvent | DecisionEndEvent)[];
    /** Clear collected events */
    clear: () => void;
    /** Visualize collected events */
    visualize: () => string;
    /** Visualize in a specific format */
    visualizeAs: (format: OutputFormat) => string;
};

export { type CollectableEvent, DecisionBranchEvent, DecisionEndEvent, DecisionStartEvent, OutputFormat, ScopeEndEvent, ScopeStartEvent, VisualizerOptions, WorkflowIR, type WorkflowVisualizer, combineEventHandlers, createEventCollector, createLiveVisualizer, createVisualizer, visualizeEvents };