import { TextMapPropagator, DiagLogLevel } from '@opentelemetry/api';
import * as api from '@opentelemetry/api';
export { api };
import { ExportResult } from '@opentelemetry/core';
import * as core from '@opentelemetry/core';
export { core };
import { ReadableSpan, Sampler, SpanExporter } from '@opentelemetry/sdk-trace-base';
import * as sdkTraceBase from '@opentelemetry/sdk-trace-base';
export { sdkTraceBase as tracing };
import { IExportTraceServiceRequest, IResource, IInstrumentationScope, IAnyValue, IKeyValue } from '@opentelemetry/otlp-transformer';
import { O as OTLPCloudflareExporterBaseConfig, a as OTLPCloudflareExporterBase } from './OTLPCloudflareExporterBase-c3bdcb30.js';
import { Resource } from '@opentelemetry/resources';
import { Diary } from 'diary';
import { L as LogRecord } from './types-c7f989f9.js';
import '@opentelemetry/otlp-exporter-base';

interface OTLPJsonTraceExporterConfig extends OTLPCloudflareExporterBaseConfig {
}
declare class OTLPJsonTraceExporter extends OTLPCloudflareExporterBase<OTLPJsonTraceExporterConfig, ReadableSpan, IExportTraceServiceRequest> {
    static fromEnv(env: Record<string, unknown>): OTLPJsonTraceExporter;
    contentType: string;
    convert(spans: ReadableSpan[]): IExportTraceServiceRequest;
    getUrl(config: OTLPCloudflareExporterBaseConfig): string;
}

interface LogExporter {
    /**
     * Called to export sampled {@link LogRecord}s.
     * @param logRecords the list of sampled LogRecords to be exported.
     */
    export(logRecords: LogRecord[], resultCallback: (result: ExportResult) => void): void;
    /** Stops the exporter. Throws in Cloudflare, added for future compat */
    shutdown(): Promise<void>;
}

type CfContext = {
    waitUntil: (promise: Promise<any>) => void;
};
type NodeSdkConfigBase = {
    /**
     * The current worker's name. Corresponds to `service.name` resource attribute.
     */
    readonly service: string;
    /**
     * Provide default resource attributes.
     */
    resource?: Resource;
    /**
     * Provide sampler for otel data. Defaults to Always On.
     * @default AlwaysOnSampler
     */
    sampler?: Sampler;
    /**
     * Provide propagator for otel. Defaults to WC3 Header and Baggage Propagators.
     * @default - W3CTraceContextPropagator & W3CBaggagePropagator
     */
    propagator?: TextMapPropagator;
    /**
     * Log Level for sdk logger implementation.
     * @default DiagLogLevel.ALL
     */
    logLevel?: DiagLogLevel;
    /**
     * Log Exporter for sdk logger implementation.
     * @default -
     */
    logExporter?: LogExporter;
    /**
     * Whether or note to send logger statements to the default console.
     * @default false
     */
    consoleLogEnabled?: boolean;
};
type NodeSdkBuiltInExporter = {
    /**
     * The OTLP HTTP Endpoint to send traces.
     */
    endpoint: string;
} & Omit<OTLPJsonTraceExporterConfig, 'url'>;
type NodeSdkExternalExporter = {
    traceExporter: SpanExporter;
};
type NodeSdkConfig = NodeSdkConfigBase & (NodeSdkBuiltInExporter | NodeSdkExternalExporter);
type Bindings<TEnv extends Record<string, unknown>> = {
    [TKey in keyof TEnv as TEnv[TKey] extends Fetcher ? TKey : never]: TEnv[TKey];
};
declare class WorkersSDK<TEnv extends Record<string, unknown> = {}> {
    #private;
    private eventOrRequest;
    private ctx;
    readonly logger: Diary;
    readonly logExportEnabled: boolean;
    get env(): Bindings<TEnv>;
    private readonly traceProvider;
    private readonly traceExporter;
    private readonly logExporter?;
    private readonly consoleLogEnabled;
    private readonly requestTracer;
    private readonly propagator;
    private readonly span;
    private readonly spanContext;
    private readonly startTime;
    private readonly allowedHeaders;
    private readonly allowedSearch;
    static fromEnv<TEnv extends Record<string, unknown> = {}>(eventOrRequest: Request | ScheduledEvent, env: TEnv, ctx: CfContext, config?: Partial<NodeSdkConfig>): WorkersSDK<TEnv>;
    constructor(eventOrRequest: Request | ScheduledEvent, ctx: CfContext, config: NodeSdkConfig);
    constructor(eventOrRequest: Request | ScheduledEvent, ctx: CfContext, environment: Record<string, unknown>, config: NodeSdkConfig);
    fetch(request: Request | string, requestInitr?: RequestInit | Request): Promise<Response>;
    sendResponse(response: Response): Response;
    res: (response: Response) => Response;
    captureException(ex: Error): void;
    private _fetch;
    private createSpan;
    private endSpan;
    end(): Promise<void>;
    private initSpan;
}

type ILogRecord = {
    timeUnixNano?: number;
    observedTimeUnixNano?: number;
    severityNumber?: number;
    severityText?: string;
    body?: IAnyValue;
    attributes?: IKeyValue[];
    droppedAttributesCount?: number;
    flags?: number | null;
    traceId?: string;
    spanId?: string;
};
type IScopeLogs = {
    scope?: IInstrumentationScope;
    logRecords: ILogRecord[];
};
type IResourceLogs = {
    resource?: IResource;
    scopeLogs: IScopeLogs[];
};
type IExportLogsServiceRequest = {
    resourceLogs: IResourceLogs[];
};

interface OTLPJsonLogExporterConfig extends OTLPCloudflareExporterBaseConfig {
}
declare class OTLPJsonLogExporter extends OTLPCloudflareExporterBase<OTLPJsonLogExporterConfig, LogRecord, IExportLogsServiceRequest> {
    contentType: string;
    static fromEnv(env: Record<string, unknown>): OTLPJsonLogExporter;
    convert(logRecords: LogRecord[]): IExportLogsServiceRequest;
    getUrl(config: OTLPCloudflareExporterBaseConfig): string;
}

export { CfContext, OTLPJsonLogExporter, OTLPJsonLogExporterConfig, OTLPJsonTraceExporter, OTLPJsonTraceExporterConfig, WorkersSDK };