import { type BaseSpan, AgentSpan, AgentType, type Event, LlmSpan, RetrieverSpan, type Span, StepWithChildSpans, ToolSpan, WorkflowSpan } from '../types/logging/span.types';
import type { JsonObject } from '../types/base.types';
import { Trace } from '../types/logging/trace.types';
import { type RetrieverSpanAllowedOutputType, type LlmSpanAllowedOutputType, type LlmSpanAllowedInputType } from '../types/logging/step.types';
import type { Payload, ProtectResponse } from 'galileo-generated';
import type { GalileoLoggerConfig, GalileoLoggerConfigExtended, IGalileoLogger, StartSessionOptions } from '../types/logging/logger.types';
declare class GalileoLogger implements IGalileoLogger {
    private projectName?;
    private logStreamName?;
    private experimentId?;
    private sessionId?;
    private localMetrics?;
    private mode?;
    private projectId?;
    private logStreamId?;
    private traceId?;
    private spanId?;
    private ingestionHook?;
    private client;
    private parentStack;
    traces: Trace[];
    private loggingDisabled;
    private taskHandler?;
    private isTerminating;
    private _terminated;
    private onTerminate?;
    /**
     * Whether terminate() has completed on this logger. Once true, subsequent mutating calls no-op
     * with a warning and the logger has been deregistered from the singleton (if applicable).
     */
    get terminated(): boolean;
    /**
     * Static factory method to create and initialize a logger.
     * Use this instead of `new GalileoLogger()` when traceId or spanId are provided.
     *
     * @param config - Logger configuration
     * @returns Promise that resolves to a fully initialized logger
     * @throws Error if config validation fails or trace/span initialization fails
     * @deprecated Use `new GalileoLogger(config)` directly. For streaming traceId/spanId initialization, call `initTrace`/`initSpan` afterward. Will be made internal in a future release.
     * @internal
     */
    static create(config?: GalileoLoggerConfigExtended): Promise<GalileoLogger>;
    /**
     * Gets the last output from a span or its children recursively.
     * @param node - (Optional) The span node to get output from.
     * @returns The output and redacted output, or undefined if not found.
     */
    static getLastOutput(node?: BaseSpan): {
        output?: string;
        redactedOutput?: string;
    } | undefined;
    constructor(config?: GalileoLoggerConfig);
    /**
     * Checks if logging is disabled.
     * @returns True if logging is disabled, false otherwise.
     */
    isLoggingDisabled(): boolean;
    /**
     * Get the current parent from context or instance.
     * @returns The current parent span or trace, or undefined if none exists.
     */
    currentParent(): StepWithChildSpans | undefined;
    /**
     * Get the previous parent (second-to-last item in the parent stack).
     * @returns The previous parent span or trace, or undefined if less than 2 items in the stack.
     */
    previousParent(): StepWithChildSpans | undefined;
    /**
     * Push a span onto the parent stack so subsequent child spans nest under it.
     * Used by handlers that need to make leaf spans (like tool) act as parents.
     */
    pushParent(span: StepWithChildSpans): void;
    /**
     * Check if there is an active trace.
     * @returns True if there is a current parent (trace or span), false otherwise.
     */
    hasActiveTrace(): boolean;
    /**
     * Gets the current session ID.
     * @returns The current session ID, or undefined if no session is active.
     */
    currentSessionId(): string | undefined;
    /**
     * Starts a session in the active logger instance. If an externalId is provided, searches for an existing session with that external ID and reuses it if found.
     *
     * Note: When an existing session is found via externalId, it is returned as-is. All other options
     * (name, previousSessionId, metadata) are ignored - they only apply when creating a new session.
     * To update an existing session, use an explicit update method.
     *
     * @param options - Configuration for the session.
     * @param options.name - (Optional) The name of the session. Only applied when creating a new session.
     * @param options.previousSessionId - (Optional) The ID of a previous session to link to. Creates a reference to the previous session but does not inherit its metadata. Only applied when creating a new session.
     * @param options.externalId - (Optional) An external identifier for the session. If a session with this external ID already exists, it will be reused instead of creating a new session.
     * @param options.metadata - (Optional) User metadata for the session as key-value string pairs. Only applied when creating a new session.
     * @returns A promise that resolves to the ID of the session (either newly created or existing).
     */
    startSession(options?: StartSessionOptions): Promise<string>;
    /**
     * Sets the session ID for the logger.
     * @param sessionId - The session ID to set.
     */
    setSessionId(sessionId: string): void;
    /**
     * Clears the current session ID.
     */
    clearSession(): void;
    /**
     * Starts a new trace.
     * @param options - Configuration for the trace.
     * @param options.input - The input content for the trace.
     * @param options.redactedInput - (Optional) Redacted version of the input.
     * @param options.output - (Optional) The output content for the trace.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the trace.
     * @param options.createdAt - (Optional) The timestamp when the trace was created.
     * @param options.durationNs - (Optional) Duration of the trace in nanoseconds.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the trace.
     * @param options.datasetInput - (Optional) Input data for dataset evaluation.
     * @param options.datasetOutput - (Optional) Expected output for dataset evaluation.
     * @param options.datasetMetadata - (Optional) Metadata for dataset evaluation.
     * @param options.externalId - (Optional) External identifier for the trace.
     * @returns The created trace.
     * @throws Error if a trace is already in progress.
     */
    startTrace(options: {
        input: string;
        redactedInput?: string;
        output?: string;
        redactedOutput?: string;
        name?: string;
        createdAt?: Date;
        durationNs?: number;
        metadata?: Record<string, string>;
        tags?: string[];
        datasetInput?: string;
        datasetOutput?: string;
        datasetMetadata?: Record<string, string>;
        externalId?: string;
    }): Trace;
    /**
     * Create a new trace with a single LLM span. This is a convenience method that combines trace creation
     * and LLM span creation in one call. The trace is automatically concluded, so no need to call conclude().
     * @param options - Configuration for the single LLM span trace. All parameters are optional except `input` and `output`.
     * @param options.input - The input content for the LLM span.
     * @param options.redactedInput - (Optional) Redacted version of the input content.
     * @param options.output - The output content from the LLM span.
     * @param options.redactedOutput - (Optional) Redacted version of the output content.
     * @param options.model - (Optional) The name or identifier of the LLM model used (e.g., 'gpt-4o', 'claude-3-sonnet').
     * @param options.tools - (Optional) Array of tool definitions. Expected format: Array<{ type: 'function', function: { name: string, description?: string, parameters?: object } }>.
     * @param options.name - (Optional) Name for the span.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.numInputTokens - (Optional) Number of tokens in the input.
     * @param options.numOutputTokens - (Optional) Number of tokens in the output.
     * @param options.totalTokens - (Optional) Total number of tokens used (input + output).
     * @param options.temperature - (Optional) The temperature parameter used for the LLM (typically 0.0-2.0).
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success).
     * @param options.spanStepNumber - (Optional) The step number for the span in a multi-step process.
     * @param options.timeToFirstTokenNs - (Optional) Time to first token in nanoseconds (for streaming).
     * @param options.datasetInput - (Optional) Input data for dataset evaluation.
     * @param options.datasetOutput - (Optional) Expected output for dataset evaluation.
     * @param options.datasetMetadata - (Optional) Metadata for dataset evaluation.
     * @param options.events - (Optional) Array of events associated with the span.
     * @returns The created trace containing the single LLM span.
     * @throws Error if a trace or span is already in progress.
     */
    addSingleLlmSpanTrace(options: {
        input: LlmSpanAllowedInputType;
        redactedInput?: LlmSpanAllowedInputType;
        output: LlmSpanAllowedOutputType;
        redactedOutput?: LlmSpanAllowedOutputType;
        model?: string;
        tools?: JsonObject[];
        name?: string;
        createdAt?: Date;
        durationNs?: number;
        metadata?: Record<string, string>;
        tags?: string[];
        numInputTokens?: number;
        numOutputTokens?: number;
        totalTokens?: number;
        temperature?: number;
        statusCode?: number;
        spanStepNumber?: number;
        timeToFirstTokenNs?: number;
        datasetInput?: string;
        datasetOutput?: string;
        datasetMetadata?: Record<string, string>;
        events?: Event[];
    }): Trace;
    /**
     * Create a new trace with a single retriever span. This is a convenience method that combines trace creation
     * and retriever span creation in one call. The trace is automatically concluded, so no need to call conclude().
     * @param options - Configuration for the single retriever span trace. All parameters are optional except `input` and `output`.
     * @param options.input - The input query for the retriever span.
     * @param options.redactedInput - (Optional) Redacted version of the input query.
     * @param options.output - The output documents or results from the retriever span.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the span.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success).
     * @param options.spanStepNumber - (Optional) The step number for the span in a multi-step process.
     * @param options.datasetInput - (Optional) Input data for dataset evaluation.
     * @param options.datasetOutput - (Optional) Expected output for dataset evaluation.
     * @param options.datasetMetadata - (Optional) Metadata for dataset evaluation.
     * @returns The created trace containing the single retriever span.
     * @throws Error if a trace or span is already in progress.
     */
    addSingleRetrieverSpanTrace(options: {
        input: string;
        redactedInput?: string;
        output: RetrieverSpanAllowedOutputType;
        redactedOutput?: RetrieverSpanAllowedOutputType;
        name?: string;
        createdAt?: Date;
        durationNs?: number;
        metadata?: Record<string, string>;
        tags?: string[];
        statusCode?: number;
        spanStepNumber?: number;
        datasetInput?: string;
        datasetOutput?: string;
        datasetMetadata?: Record<string, string>;
    }): Trace;
    /**
     * Create a new trace with a single tool span. This is a convenience method that combines trace creation
     * and tool span creation in one call. The trace is automatically concluded, so no need to call conclude().
     * @param options - Configuration for the single tool span trace. Only `input` is required.
     * @param options.input - The input parameters for the tool span.
     * @param options.redactedInput - (Optional) Redacted version of the input.
     * @param options.output - (Optional) The output result from the tool span.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the span (e.g., the tool name or function name).
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success).
     * @param options.toolCallId - (Optional) Unique identifier for the tool call.
     * @param options.spanStepNumber - (Optional) The step number for the span in a multi-step process.
     * @param options.datasetInput - (Optional) Input data for dataset evaluation.
     * @param options.datasetOutput - (Optional) Expected output for dataset evaluation.
     * @param options.datasetMetadata - (Optional) Metadata for dataset evaluation.
     * @returns The created trace containing the single tool span.
     * @throws Error if a trace or span is already in progress.
     */
    addSingleToolSpanTrace(options: {
        input: string;
        redactedInput?: string;
        output?: string;
        redactedOutput?: string;
        name?: string;
        createdAt?: Date;
        durationNs?: number;
        metadata?: Record<string, string>;
        tags?: string[];
        statusCode?: number;
        toolCallId?: string;
        spanStepNumber?: number;
        datasetInput?: string;
        datasetOutput?: string;
        datasetMetadata?: Record<string, string>;
    }): Trace;
    /**
     * Create a new trace with a single workflow span. This is a convenience method that combines trace creation
     * and workflow span creation in one call. The trace is automatically concluded, so no need to call conclude().
     * @param options - Configuration for the single workflow span trace. Only `input` is required.
     * @param options.input - The input content for the workflow span.
     * @param options.redactedInput - (Optional) Redacted version of the input.
     * @param options.output - (Optional) The output result from the workflow span.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the span.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.spanStepNumber - (Optional) The step number for the span in a multi-step process.
     * @param options.datasetInput - (Optional) Input data for dataset evaluation.
     * @param options.datasetOutput - (Optional) Expected output for dataset evaluation.
     * @param options.datasetMetadata - (Optional) Metadata for dataset evaluation.
     * @returns The created trace containing the single workflow span.
     * @throws Error if a trace or span is already in progress.
     */
    addSingleWorkflowSpanTrace(options: {
        input: string;
        redactedInput?: string;
        output?: string;
        redactedOutput?: string;
        name?: string;
        createdAt?: Date;
        durationNs?: number;
        metadata?: Record<string, string>;
        tags?: string[];
        spanStepNumber?: number;
        datasetInput?: string;
        datasetOutput?: string;
        datasetMetadata?: Record<string, string>;
    }): Trace;
    /**
     * Concludes the current trace or span, or all active traces/spans if concludeAll is true.
     * @param options - Configuration for concluding.
     * @param options.output - (Optional) The output content to set.
     * @param options.redactedOutput - (Optional) The redacted output content to set.
     * @param options.durationNs - (Optional) Duration in nanoseconds.
     * @param options.statusCode - (Optional) HTTP status code or execution status.
     * @param options.concludeAll - (Optional) Whether to conclude all active traces/spans. Defaults to false.
     * @returns The current parent after concluding, or undefined if all traces/spans were concluded.
     * @throws Error if no trace or span exists to conclude.
     */
    conclude(options?: {
        output?: string;
        redactedOutput?: string;
        durationNs?: number;
        statusCode?: number;
        concludeAll?: boolean;
    }): StepWithChildSpans | undefined;
    /**
     * Add a child span to the current parent (trace or workflow/agent span).
     * This method automatically propagates dataset information from the parent to the child span.
     * @param span - The span to add as a child to the current parent.
     * @throws Error if no trace or parent span exists.
     */
    addChildSpanToParent(span: Span): void;
    /**
     * Add a new LLM span to the current parent.
     * @param options - Configuration for the LLM span. All parameters are optional except `input` and `output`.
     * @param options.input - The input content for the LLM span. Accepts string, Message, or arrays of these.
     * @param options.redactedInput - (Optional) Redacted version of the input content.
     * @param options.output - The output content from the LLM span. Accepts string, Message, or arrays of these.
     * @param options.redactedOutput - (Optional) Redacted version of the output content.
     * @param options.model - (Optional) The name or identifier of the LLM model used (e.g., 'gpt-4o', 'claude-3-sonnet').
     * @param options.tools - (Optional) Array of tool definitions available to the LLM.
     * @param options.name - (Optional) Name for the span.
     * @param options.createdAt - (Optional) The timestamp when the span was created. Defaults to current time if not provided.
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.numInputTokens - (Optional) Number of tokens in the input.
     * @param options.numOutputTokens - (Optional) Number of tokens in the output.
     * @param options.totalTokens - (Optional) Total number of tokens used (input + output).
     * @param options.timeToFirstTokenNs - (Optional) Time to first token in nanoseconds (for streaming responses).
     * @param options.temperature - (Optional) The temperature parameter used for the LLM (typically 0.0-2.0).
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success).
     * @param options.stepNumber - (Optional) The step number in a multi-step process.
     * @param options.events - (Optional) Array of events associated with the span.
     * @returns The created LLM span, which is automatically added to the current parent.
     */
    addLlmSpan(options: {
        input: LlmSpanAllowedInputType;
        redactedInput?: LlmSpanAllowedInputType;
        output: LlmSpanAllowedOutputType;
        redactedOutput?: LlmSpanAllowedOutputType;
        model?: string;
        tools?: JsonObject[];
        name?: string;
        createdAt?: Date;
        durationNs?: number;
        metadata?: Record<string, string>;
        tags?: string[];
        numInputTokens?: number;
        numOutputTokens?: number;
        totalTokens?: number;
        numReasoningTokens?: number;
        numCachedInputTokens?: number;
        timeToFirstTokenNs?: number;
        temperature?: number;
        statusCode?: number;
        stepNumber?: number;
        events?: Event[];
    }): LlmSpan;
    /**
     * Add a new retriever span to the current parent.
     * @param options - Configuration for the retriever span. All parameters are optional except `input` and `output`.
     * @param options.input - The input query for the retriever.
     * @param options.redactedInput - (Optional) Redacted version of the input query.
     * @param options.output - The output documents or results. Accepts string, Record<string, string>, Document, or arrays of these. Document has properties: { content: string, metadata?: Record<string, string | number | boolean> }.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the span.
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success).
     * @param options.stepNumber - (Optional) The step number in a multi-step process.
     * @returns The created retriever span.
     */
    addRetrieverSpan(options: {
        input: string;
        redactedInput?: string;
        output: RetrieverSpanAllowedOutputType;
        redactedOutput?: RetrieverSpanAllowedOutputType;
        name?: string;
        durationNs?: number;
        createdAt?: Date;
        metadata?: Record<string, string>;
        tags?: string[];
        statusCode?: number;
        stepNumber?: number;
    }): RetrieverSpan;
    /**
     * Add a new tool span to the current parent.
     * @param options - Configuration for the tool span. Only `input` is required.
     * @param options.input - The input parameters for the tool.
     * @param options.redactedInput - (Optional) Redacted version of the input.
     * @param options.output - (Optional) The output result from the tool.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the span (e.g., the tool name or function name).
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success).
     * @param options.toolCallId - (Optional) Unique identifier for the tool call, typically from LLM tool_calls (e.g., 'call_abc123').
     * @param options.stepNumber - (Optional) The step number in a multi-step process.
     * @returns The created tool span.
     */
    addToolSpan(options: {
        input: string;
        redactedInput?: string;
        output?: string;
        redactedOutput?: string;
        name?: string;
        durationNs?: number;
        createdAt?: Date;
        metadata?: Record<string, string>;
        tags?: string[];
        statusCode?: number;
        toolCallId?: string;
        stepNumber?: number;
    }): ToolSpan;
    /**
     * Add a new Protect tool span to the current parent.
     * This is a specialized method for logging Galileo Protect tool spans.
     * @param options - Configuration for the Protect span.
     * @param options.payload - Input to the Protect invoke method. Payload object with input and/or output attributes.
     * @param options.redactedPayload - (Optional) Redacted version of the payload.
     * @param options.response - (Optional) Output from the Protect invoke method. Response object with text, traceMetadata, and status.
     * @param options.redactedResponse - (Optional) Redacted version of the response.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success).
     * @param options.stepNumber - (Optional) The step number in a multi-step process.
     * @returns The created Protect tool span.
     */
    addProtectSpan(options: {
        payload: Payload;
        redactedPayload?: Payload;
        response?: ProtectResponse;
        redactedResponse?: ProtectResponse;
        createdAt?: Date;
        metadata?: Record<string, string>;
        tags?: string[];
        statusCode?: number;
        stepNumber?: number;
    }): ToolSpan;
    /**
     * Add a workflow span to the current parent. This is useful when you want to create a nested workflow span
     * within the trace or current workflow span. The next span you add will be a child of the current parent. To
     * move out of the nested workflow, use conclude().
     * @param options - Configuration for the workflow span. Only `input` is required. This creates a parent span that can contain child spans.
     * @param options.input - The input content for the workflow.
     * @param options.redactedInput - (Optional) Redacted version of the input.
     * @param options.output - (Optional) The output result from the workflow.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the span (e.g., 'Data Processing Workflow').
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.statusCode - (Optional) HTTP status code or execution status (e.g., 200 for success, 500 for error).
     * @param options.stepNumber - (Optional) The step number in a multi-step process.
     * @returns The created workflow span.
     */
    addWorkflowSpan(options: {
        input: string;
        redactedInput?: string;
        output?: string;
        redactedOutput?: string;
        name?: string;
        durationNs?: number;
        createdAt?: Date;
        metadata?: Record<string, string>;
        tags?: string[];
        statusCode?: number;
        stepNumber?: number;
    }): WorkflowSpan;
    /**
     * Add an agent span to the current parent. Agent spans can contain child spans (like workflow spans).
     * @param options - Configuration for the agent span. Only `input` is required. This creates a parent span that can contain child spans.
     * @param options.input - The input content for the agent.
     * @param options.redactedInput - (Optional) Redacted version of the input.
     * @param options.output - (Optional) The output result from the agent.
     * @param options.redactedOutput - (Optional) Redacted version of the output.
     * @param options.name - (Optional) Name for the span (e.g., 'Planning Agent', 'Router Agent').
     * @param options.durationNs - (Optional) Duration of the span in nanoseconds.
     * @param options.createdAt - (Optional) The timestamp when the span was created.
     * @param options.metadata - (Optional) Additional metadata as key-value pairs.
     * @param options.tags - (Optional) Array of tags to categorize the span.
     * @param options.agentType - (Optional) The type of agent. One of: 'default', 'planner', 'react', 'reflection', 'router', 'classifier', 'supervisor', 'judge'. Defaults to 'default'.
     * @param options.stepNumber - (Optional) The step number in a multi-step process.
     * @returns The created agent span.
     */
    addAgentSpan(options: {
        input: string;
        redactedInput?: string;
        output?: string;
        redactedOutput?: string;
        name?: string;
        durationNs?: number;
        createdAt?: Date;
        metadata?: Record<string, string>;
        tags?: string[];
        agentType?: AgentType;
        statusCode?: number;
        stepNumber?: number;
    }): AgentSpan;
    /**
     * Flushes all traces to the server. Concludes any active traces before flushing.
     * When an ingestionHook is configured, traces are sent to the hook instead of the
     * API and client initialization is skipped (no API credentials required).
     * @returns A promise that resolves to an array of flushed traces.
     */
    flush(): Promise<Trace[]>;
    /**
     * Terminates the logger. In batch mode, flushes all traces. In streaming mode, waits for all tasks to complete.
     * After termination, subsequent mutating calls no-op with a warning, and loggers created through the
     * singleton are removed from the singleton's registry. Calling terminate() again is a no-op.
     * @returns A promise that resolves when termination is complete.
     */
    terminate(): Promise<void>;
    private initializeProperties;
    private validateConfiguration;
    private initializeLoggerState;
    private applySharedGuards;
    private wrapMethodsForDisabledLogging;
    private wrapMethodsForTerminated;
    private registerCleanupHandlers;
    /**
     * Initializes a trace from the API using the provided traceId. Fetches the trace and adds it to the traces array and parent stack.
     * @param traceId - The ID of the trace to initialize.
     * @param addToParentStack - (Optional) Whether to add the trace to the parent stack. Defaults to true.
     */
    private initTrace;
    /**
     * Initialize a span from the API using the provided spanId.
     * Fetches the span, validates it belongs to the trace, and adds it to the parent stack.
     * Only workflow and agent spans can be initialized.
     */
    private initSpan;
    /**
     * Continues an existing trace (and optionally a parent span) for distributed tracing.
     * Fetches the trace (and span if parentId is provided) from the API and sets them as current context.
     *
     * @param traceId - The ID of the trace to continue.
     * @param parentId - (Optional) The ID of the parent span to continue under.
     * @returns A promise that resolves when the trace (and optional span) context is set.
     */
    continueTrace(traceId: string, parentId?: string): Promise<void>;
    /**
     * Ensures the Galileo API client is initialized with the current logger's configuration.
     *
     * This method initializes the client with the logger's project, log stream, experiment,
     * and session settings. Uses `forceInit: false` to avoid re-initializing if the client
     * is already initialized, making it safe to call multiple times.
     *
     * @throws Error if client initialization fails
     */
    private ensureClientInitialized;
    /**
     * Get the parent stack from context or instance, maintaining backward compatibility.
     * @returns The parent stack array.
     */
    private getParentStack;
    /**
     * Set the parent stack in context and instance.
     * @param stack - The parent stack to set.
     */
    private setParentStack;
    /**
     * Ingests a trace in streaming mode.
     * @param trace - The trace to ingest.
     * @param isComplete - (Optional) Whether the trace is complete. Defaults to false.
     */
    private ingestTraceStreaming;
    /**
     * Ingest a span in streaming mode.
     * @param span - The span to ingest.
     */
    private ingestSpanStreaming;
    /**
     * Updates a trace in streaming mode.
     * @param trace - The trace to update.
     * @param isComplete - (Optional) Whether the trace is complete. Defaults to false.
     */
    private updateTraceStreaming;
    /**
     * Update a span in streaming mode.
     * @param span - The span to update.
     */
    private updateSpanStreaming;
    /**
     * Generic streaming operation handler that wraps retry logic and task submission.
     * Handles the common pattern used by ingestTraceStreaming, ingestSpanStreaming, updateTraceStreaming and updateSpanStreaming.
     *
     * @param taskId - Unique identifier for the task
     * @param operation - The async operation to execute with retry logic
     * @param dependentOnTaskId - (Optional) Task ID to depend on for ordering
     */
    private submitStreamingTask;
    /**
     * Concludes the current trace or workflow span by setting the output of the current node. In the case of nested workflow spans, this will point the workflow back to the parent of the current workflow span.
     * @param options - Configuration for concluding.
     * @param options.output - (Optional) The output content to set.
     * @param options.redactedOutput - (Optional) The redacted output content to set.
     * @param options.durationNs - (Optional) Duration in nanoseconds.
     * @param options.statusCode - (Optional) HTTP status code or execution status.
     * @returns The current parent after concluding, or undefined.
     * @throws Error if no trace or span exists to conclude.
     */
    private concludeCurrentParent;
}
export { GalileoLogger, Trace, StepWithChildSpans, LlmSpan, RetrieverSpan, ToolSpan, WorkflowSpan, AgentSpan };
export type { GalileoLoggerConfig, Span };