import { a2 as TraceExporter, Q as SpanType, O as Span } from '../../types-Ks98Z0E_.mjs';
export { P as SpanEvent } from '../../types-Ks98Z0E_.mjs';
import 'zod';

/**
 * EADK Tracer
 *
 * Automatic trace collection with span management.
 * Combines OpenAI Agents SDK tracing with OpenTelemetry export.
 */

/**
 * Tracer collects spans during agent execution and exports them.
 */
declare class Tracer {
    private spans;
    private exporters;
    private traceId;
    private enabled;
    constructor(options?: {
        exporters?: TraceExporter[];
        enabled?: boolean;
    });
    /**
     * Start a new span.
     */
    startSpan(options: {
        name: string;
        type: SpanType;
        parentId?: string;
        attributes?: Record<string, unknown>;
    }): Span;
    /**
     * End a span and export it.
     */
    endSpan(spanId: string, status?: 'ok' | 'error', error?: Error): void;
    /**
     * Add an event to a span.
     */
    addSpanEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
    /**
     * Set span attributes.
     */
    setSpanAttributes(spanId: string, attributes: Record<string, unknown>): void;
    /**
     * Get all collected spans.
     */
    getSpans(): Span[];
    /**
     * Get a specific span by ID.
     */
    getSpan(spanId: string): Span | undefined;
    /**
     * Get the current trace ID.
     */
    getTraceId(): string;
    /**
     * Flush all exporters.
     */
    flush(): Promise<void>;
    /**
     * Clear all spans (for testing).
     */
    clear(): void;
    /**
     * Add an exporter.
     */
    addExporter(exporter: TraceExporter): void;
}
declare function getGlobalTracer(): Tracer;
declare function setGlobalTracer(tracer: Tracer): void;

/**
 * Console Trace Exporter
 *
 * Logs spans to the console for development and debugging.
 */

declare class ConsoleExporter implements TraceExporter {
    private verbose;
    constructor(options?: {
        verbose?: boolean;
    });
    exportSpan(span: Span): void;
    flush(): Promise<void>;
}

/**
 * OpenTelemetry Trace Exporter
 *
 * Exports spans in OpenTelemetry-compatible format.
 * Can be configured to send to any OTel collector endpoint.
 */

interface OTelExporterConfig {
    /** OTel collector endpoint */
    endpoint: string;
    /** Service name */
    serviceName?: string;
    /** Additional headers */
    headers?: Record<string, string>;
    /** Batch size before flush */
    batchSize?: number;
}
declare class OpenTelemetryExporter implements TraceExporter {
    private config;
    private buffer;
    private batchSize;
    constructor(config: OTelExporterConfig);
    exportSpan(span: Span): void;
    flush(): Promise<void>;
    private toOTelSpan;
    private toHexId;
    private toUnixNanos;
    private toAnyValue;
}

/**
 * Edgework Metrics Exporter
 *
 * Integrates with existing edgework MetricsReporter for
 * edge-native observability (latency, p2p routing, etc.).
 */

interface EdgeworkExporterConfig {
    /** Callback to report spans to existing MetricsReporter */
    onSpan?: (span: Span) => void;
    /** Whether to include edge-specific attributes */
    includeEdgeMetrics?: boolean;
}
declare class EdgeworkMetricsExporter implements TraceExporter {
    private config;
    private spans;
    constructor(config?: EdgeworkExporterConfig);
    exportSpan(span: Span): void;
    flush(): Promise<void>;
    /**
     * Get performance summary for all collected spans.
     */
    getSummary(): {
        totalSpans: number;
        byType: Record<string, number>;
        averageLatency: Record<string, number>;
        errors: number;
    };
}

export { ConsoleExporter, type EdgeworkExporterConfig, EdgeworkMetricsExporter, type OTelExporterConfig, OpenTelemetryExporter, Span, SpanType, TraceExporter, Tracer, getGlobalTracer, setGlobalTracer };