import { LogWriter, LogLevel, Attributes, Logger as Logger$1 } from '@graphql-hive/logger';
import { Context, ContextManager, TextMapPropagator, TracerProvider } from '@opentelemetry/api';
import { Resource } from '@opentelemetry/resources';
import { BufferConfig, SpanProcessor, Span, GeneralLimits, Sampler, SpanLimits, SpanExporter } from '@opentelemetry/sdk-trace-base';
export { SEMATTRS_GRAPHQL_DOCUMENT, SEMATTRS_GRAPHQL_OPERATION_NAME, SEMATTRS_GRAPHQL_OPERATION_TYPE, SEMATTRS_HIVE_GATEWAY_OPERATION_SUBGRAPH_NAMES, SEMATTRS_HIVE_GATEWAY_UPSTREAM_SUBGRAPH_NAME, SEMATTRS_HIVE_GRAPHQL_ERROR_CODES, SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT, SEMATTRS_HIVE_GRAPHQL_OPERATION_HASH, SEMATTRS_HIVE_REQUEST_ID, SEMATTRS_IS_HIVE_GRAPHQL_OPERATION, SEMATTRS_IS_HIVE_REQUEST, SEMATTRS_IS_HIVE_SUBGRAPH_EXECUTION } from './attributes.cjs';
import { SeverityNumber, Logger } from '@opentelemetry/api-logs';
import { LoggerProvider, LogRecordLimits, LogRecordProcessor, LogRecordExporter } from '@opentelemetry/sdk-logs';
import { CircuitBreakerConfiguration } from '@graphql-hive/core';
export { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, SEMATTRS_HTTP_CLIENT_IP, SEMATTRS_HTTP_HOST, SEMATTRS_HTTP_METHOD, SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_SCHEME, SEMATTRS_HTTP_SERVER_NAME, SEMATTRS_HTTP_STATUS_CODE, SEMATTRS_HTTP_URL, SEMATTRS_HTTP_USER_AGENT, SEMATTRS_NET_HOST_NAME } from '@opentelemetry/semantic-conventions';

type ProcessorOptions = {
    forceFlushTimeoutMillis?: number;
    logRecordLimits?: LogRecordLimits;
    resource?: Resource;
    console?: boolean;
};
type OpenTelemetryLogWriterSetupOptions = {
    logger: Logger;
} | {
    provider: LoggerProvider;
} | (ProcessorOptions & ({
    processors: LogRecordProcessor[];
    exporter?: never;
} | {
    exporter: LogRecordExporter;
    batching?: boolean | BufferConfig;
    processors?: never;
} | {
    console: boolean;
    processors?: never;
    exporter?: never;
}));
type OpenTelemetryLogWriterOptions = OpenTelemetryLogWriterSetupOptions & {
    useContextManager?: boolean;
};
declare class OpenTelemetryLogWriter implements LogWriter {
    private logger;
    private useContextManager;
    constructor(options: OpenTelemetryLogWriterOptions);
    flush(): void | Promise<void>;
    write(level: LogLevel, attrs: Attributes | null | undefined, msg: string | null | undefined): void | Promise<void>;
}
declare const HIVE_LOG_LEVEL_NUMBERS: {
    trace: SeverityNumber;
    debug: SeverityNumber;
    info: SeverityNumber;
    warn: SeverityNumber;
    error: SeverityNumber;
};
declare function getContextForRequest(attributes?: {
    requestId?: string;
}): Context;

type HiveTracingSpanProcessorOptions = {
    target: string;
    accessToken: string;
    endpoint: string;
    batching?: BufferConfig;
    processor?: never;
    circuitBreaker?: CircuitBreakerConfiguration;
    log?: Logger$1;
} | {
    processor: SpanProcessor;
};
declare class HiveTracingSpanProcessor implements SpanProcessor {
    private traceStateById;
    private processor;
    constructor(config: HiveTracingSpanProcessorOptions);
    onStart(span: Span, parentContext: Context): void;
    onEnd(span: Span): void;
    forceFlush(): Promise<void>;
    shutdown(): Promise<void>;
}

type TracingOptions = {
    traces?: {
        /**
         * A custom Trace Provider.
         */
        tracerProvider: TracerProvider;
    } | (TracerOptions & ({
        /**
         * The span processors that will be used to process recorded spans.
         * All processors will receive all recorded spans.
         */
        processors: SpanProcessor[];
        tracerProvider?: never;
        exporter?: never;
    } | {
        /**
         * The exporter that will be used to send spans.
         */
        exporter: SpanExporter;
        /**
         * The batching options. By default, spans are batched using default BatchProcessor.
         * You can pass `false` to entirely disable batching (not recommended for production).
         */
        batching?: BatchingConfig | boolean;
        tracerProvider?: never;
        processors?: never;
    } | {
        tracerProvider?: never;
        processors?: never;
        exporter?: never;
    }));
};
type TracerOptions = {
    /**
     * If true, adds a Console Exporter that will write to stdout all spans.
     * This can be used for debug purposes if you struggle to receive spans.
     */
    console?: boolean;
    /**
     * The limits of the Span API like spans and attribute sizes
     */
    spanLimits?: SpanLimits;
};
type SamplingOptions = {
    /**
     * A custom sampling strategy
     */
    sampler: Sampler;
    samplingRate?: never;
} | {
    sampler?: never;
    /**
     * A sampler rate based on Parent First and Trace Id consistent probabilistic strategy.
     * Set to 1 to record all traces, 0 to record none.
     */
    samplingRate?: number;
};
type BaseOptions = {
    /**
     * The Resource that will be used to create the Trace Provider.
     * Can be either a Resource instance, or an simple object with service name and version
     */
    resource?: Resource | {
        serviceName: string;
        serviceVersion?: string;
    };
    /**
     * The Context Manager to be used to track OTEL Context.
     * If possible, use `AsyncLocalStorageContextManager` from `@opentelemetry/context-async-hooks`.
     */
    contextManager: ContextManager | null;
    /**
     * A custom list of propagators that will replace the default ones (Trace Context and Baggage)
     */
    propagators?: TextMapPropagator[];
    /**
     * The general limits of OTEL attributes.
     */
    generalLimits?: GeneralLimits;
    /**
     * The Logger to be used by this utility.
     * A child of this logger will be used for OTEL diag API, unless `configureDiagLogger` is false
     */
    log?: Logger$1;
    /**
     * Configure Opentelemetry `diag` API to use Gateway's logger.
     *
     * @default true
     *
     * Note: Logger configuration respects OTEL environment variables standard.
     *       This means that the logger will be enabled only if `OTEL_LOG_LEVEL` variable is set.
     */
    configureDiagLogger?: boolean;
    /** @internal */
    _initialization?: typeof initialized & {
        logAttributes: Attributes;
    };
};
type OpentelemetrySetupOptions = TracingOptions & SamplingOptions & BaseOptions;
declare let initialized: false | {
    name: string;
    source: string;
};
declare function openTelemetrySetup(options: OpentelemetrySetupOptions): void;
type HiveTracingOptions = {
    target?: string;
} & ({
    accessToken?: string;
    batching?: BufferConfig;
    processor?: never;
    /** @default 'https://api.graphql-hive.com/otel/v1/traces' */
    endpoint?: string;
} | {
    processor: SpanProcessor;
});
type HiveTracingSetupOptions = BaseOptions & HiveTracingOptions & SamplingOptions & TracerOptions;
declare function hiveTracingSetup(options: HiveTracingSetupOptions): void;
type BatchingConfig = boolean | BufferConfig;
/**
 * Reset OpenTelemetry setup by disabling `trace`, `context` and `propagation` OpenTelemetry APIs.
 */
declare function disable(): void;

export { type BatchingConfig, HIVE_LOG_LEVEL_NUMBERS, type HiveTracingOptions, type HiveTracingSetupOptions, HiveTracingSpanProcessor, type HiveTracingSpanProcessorOptions, OpenTelemetryLogWriter, type OpenTelemetryLogWriterOptions, type OpenTelemetryLogWriterSetupOptions, disable, getContextForRequest, hiveTracingSetup, openTelemetrySetup };