import { TracingProcessor } from './processor';
type SpanDataBase = {
    type: string;
};
export type AgentSpanData = SpanDataBase & {
    type: 'agent';
    name: string;
    handoffs?: string[];
    tools?: string[];
    output_type?: string;
};
export type TurnUsageData = {
    input_tokens: number;
    output_tokens: number;
    cached_input_tokens: number;
    cache_write_input_tokens: number;
};
export type TaskUsageData = TurnUsageData & {
    requests: number;
    total_tokens: number;
};
export type TaskSpanData = SpanDataBase & {
    type: 'task';
    name: string;
    usage?: TaskUsageData;
};
export type TurnSpanData = SpanDataBase & {
    type: 'turn';
    turn: number;
    agent_name: string;
    usage?: TurnUsageData;
};
export type FunctionSpanData = SpanDataBase & {
    type: 'function';
    name: string;
    input: string;
    output: string;
    mcp_data?: string;
};
export type GenerationUsageData = {
    input_tokens?: number;
    output_tokens?: number;
    details?: Record<string, unknown> | null;
    [key: string]: unknown;
};
export type GenerationSpanData = SpanDataBase & {
    type: 'generation';
    input?: Array<Record<string, any>>;
    output?: Array<Record<string, any>>;
    /**
     * Tool definitions offered to the model, including handoffs. Chat Completions
     * captures these for processors when sensitive data is enabled. The OpenAI
     * tracing exporter omits them from hosted ingest.
     */
    tools?: Array<Record<string, any>>;
    model?: string;
    model_config?: Record<string, any>;
    /**
     * Usage fields are intentionally flexible in agents-core tracing.
     *
     * Exporters are responsible for backend-specific mapping and validation.
     * For example, the OpenAI tracing exporter in `@openai/agents-openai` keeps
     * top-level generation usage to `input_tokens` and `output_tokens` for OpenAI
     * traces ingest, and maps additional usage fields under `usage.details`.
     * Third-party exporters can choose their own usage schema and transformation
     * strategy.
     */
    usage?: GenerationUsageData;
};
export type ResponseSpanData = SpanDataBase & {
    type: 'response';
    response_id?: string;
    /**
     * Not used by the OpenAI tracing provider but helpful for other tracing providers.
     */
    _input?: string | Record<string, any>[];
    _response?: Record<string, any>;
};
export type HandoffSpanData = SpanDataBase & {
    type: 'handoff';
    from_agent?: string;
    to_agent?: string;
};
export type CustomSpanData = SpanDataBase & {
    type: 'custom';
    name: string;
    data: Record<string, any>;
};
export type GuardrailSpanData = SpanDataBase & {
    type: 'guardrail';
    name: string;
    triggered: boolean;
};
export type TranscriptionSpanData = SpanDataBase & {
    type: 'transcription';
    input: {
        data: string;
        format: 'pcm' | (string & {});
    };
    output?: string;
    model?: string;
    model_config?: Record<string, any>;
};
export type SpeechSpanData = SpanDataBase & {
    type: 'speech';
    input?: string;
    output: {
        data: string;
        format: 'pcm' | (string & {});
    };
    model?: string;
    model_config?: Record<string, any>;
};
export type SpeechGroupSpanData = SpanDataBase & {
    type: 'speech_group';
    input?: string;
};
export type MCPListToolsSpanData = SpanDataBase & {
    type: 'mcp_tools';
    server?: string;
    result?: string[];
};
export type SpanData = AgentSpanData | TaskSpanData | TurnSpanData | FunctionSpanData | GenerationSpanData | ResponseSpanData | HandoffSpanData | CustomSpanData | GuardrailSpanData | TranscriptionSpanData | SpeechSpanData | SpeechGroupSpanData | MCPListToolsSpanData;
export type SpanOptions<TData extends SpanData> = {
    traceId: string;
    spanId?: string;
    parentId?: string;
    data: TData;
    traceMetadata?: Record<string, any>;
    startedAt?: string;
    endedAt?: string;
    error?: SpanError;
    tracingApiKey?: string;
};
export type SpanError = {
    message: string;
    data?: Record<string, any>;
};
export declare class Span<TData extends SpanData> {
    #private;
    type: "trace.span";
    constructor(options: SpanOptions<TData>, processor: TracingProcessor);
    get traceId(): string;
    get spanData(): TData;
    get traceMetadata(): Record<string, any> | undefined;
    get spanId(): string;
    get parentId(): string | null;
    get previousSpan(): Span<any> | undefined;
    set previousSpan(span: Span<any> | undefined);
    start(): void;
    end(): void;
    setError(error: SpanError): void;
    get error(): SpanError | null;
    get startedAt(): string | null;
    get endedAt(): string | null;
    get tracingApiKey(): string | undefined;
    clone(): Span<TData>;
    toJSON(): object | null;
}
export declare class NoopSpan<TSpanData extends SpanData> extends Span<TSpanData> {
    constructor(data: TSpanData, processor: TracingProcessor);
    start(): void;
    end(): void;
    setError(): void;
    toJSON(): null;
}
export {};