import { a as MetricExemplar, b as MetricSnapshot, M as MetricsRegistry, T as TraceSampler, c as TraceSamplingInput, E as EventBus, B as BrassEnv, I as InMemoryTracer, d as Tracer, R as RuntimeSpan, e as InMemoryTracerOptions } from './tracer-CS3yOXZx.js';
import { T as TraceContext, R as RuntimeHooks, A as Async, J as JSONValue, B as Baggage, b as Runtime, h as RuntimeRegistry, a as RuntimeOptions } from './effect-DbEMiMvv.js';
import { C as CircuitBreakerStats } from './layer-CsNGeVee.js';
import { A as AdaptiveLimiterStats } from './defaultClient-DLOa3gdw.js';

declare const PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
declare const OTLP_JSON_CONTENT_TYPE = "application/json";
type PrometheusMetricsOptions = {
    readonly prefix?: string;
    readonly includeTimestamp?: boolean;
    readonly includeExemplars?: boolean;
    readonly help?: Record<string, string>;
    readonly now?: () => number;
};
type PrometheusMetricsExporter = {
    readonly contentType: string;
    readonly export: () => string;
};
type OtlpAttributeValue = string | number | boolean;
type OtlpExportOptions = {
    readonly resource?: Record<string, OtlpAttributeValue>;
    readonly scopeName?: string;
    readonly scopeVersion?: string;
    readonly now?: () => number;
};
type OtlpHttpResponse = {
    readonly ok?: boolean;
    readonly status?: number;
    readonly statusText?: string;
    readonly text?: () => Promise<string>;
};
type OtlpFetch = (url: string, init: {
    readonly method: "POST";
    readonly headers: Record<string, string>;
    readonly body: string;
}) => Promise<OtlpHttpResponse>;
type OtlpHttpExporterOptions = OtlpExportOptions & {
    readonly url: string;
    readonly headers?: Record<string, string>;
    readonly fetch?: OtlpFetch;
};
type OtlpHttpExportResult = {
    readonly status?: number;
    readonly body: string;
};
type RuntimeMetricsSinkOptions = {
    readonly durationBuckets?: readonly number[];
    readonly clock?: () => number;
    readonly includeEventTotals?: boolean;
    readonly includeSpanNameLabel?: boolean;
};
declare function makePrometheusMetricsExporter(registry: MetricsRegistry, options?: PrometheusMetricsOptions): PrometheusMetricsExporter;
declare function formatPrometheusMetrics(snapshot: MetricSnapshot, options?: PrometheusMetricsOptions): string;
declare function metricsSnapshotToOtlp(snapshot: MetricSnapshot, options?: OtlpExportOptions): {
    resourceMetrics: {
        resource: {
            attributes: {
                key: string;
                value: {
                    boolValue: boolean;
                    doubleValue?: undefined;
                    stringValue?: undefined;
                } | {
                    doubleValue: number;
                    boolValue?: undefined;
                    stringValue?: undefined;
                } | {
                    stringValue: string;
                    boolValue?: undefined;
                    doubleValue?: undefined;
                };
            }[];
        };
        scopeMetrics: {
            scope: Record<string, unknown>;
            metrics: Record<string, unknown>[];
        }[];
    }[];
};
declare function makeOtlpHttpMetricsExporter(registry: MetricsRegistry, options: OtlpHttpExporterOptions): {
    export: () => Promise<OtlpHttpExportResult>;
};
declare function makeRuntimeMetricsSink(metrics: MetricsRegistry, options?: RuntimeMetricsSinkOptions): RuntimeHooks;
declare function exemplarFromTraceContext(trace: Pick<Partial<TraceContext>, "traceId" | "spanId"> | undefined, value: number, timestamp?: number, labels?: Record<string, string>): MetricExemplar | undefined;
declare function toOtlpAttributes(labels: Record<string, OtlpAttributeValue>): {
    key: string;
    value: {
        boolValue: boolean;
        doubleValue?: undefined;
        stringValue?: undefined;
    } | {
        doubleValue: number;
        boolValue?: undefined;
        stringValue?: undefined;
    } | {
        stringValue: string;
        boolValue?: undefined;
        doubleValue?: undefined;
    };
}[];
declare function otlpAnyValue(value: OtlpAttributeValue): {
    boolValue: boolean;
    doubleValue?: undefined;
    stringValue?: undefined;
} | {
    doubleValue: number;
    boolValue?: undefined;
    stringValue?: undefined;
} | {
    stringValue: string;
    boolValue?: undefined;
    doubleValue?: undefined;
};
declare function postOtlpJson(options: OtlpHttpExporterOptions, body: string): Promise<OtlpHttpResponse>;
declare function unixNanoFromMs(ms: number): string;

type RedactionOptions = {
    readonly keys?: readonly (string | RegExp)[];
    readonly headers?: readonly (string | RegExp)[];
    readonly replacement?: string;
    readonly redactUrlQuery?: boolean;
    readonly maxDepth?: number;
    readonly maxStringLength?: number;
};
type ObservabilityRedactor = {
    readonly value: (value: unknown) => unknown;
    readonly fields: (fields: Record<string, unknown>) => Record<string, unknown>;
    readonly attributes: (fields: Record<string, unknown>) => Record<string, unknown>;
    readonly headers: (headers: Record<string, string>) => Record<string, string>;
    readonly url: (url: string) => string;
};
type RedactionConfig = false | RedactionOptions | ObservabilityRedactor;
declare function makeObservabilityRedactor(config: RedactionConfig | undefined): ObservabilityRedactor;

type LogLevel = "debug" | "info" | "warn" | "error";
type StructuredLogRecord = {
    readonly ts: string;
    readonly wallTs: number;
    readonly level: LogLevel;
    readonly message: string;
    readonly fields: Record<string, unknown>;
    readonly fiberId?: number;
    readonly scopeId?: number;
    readonly traceId?: string;
    readonly spanId?: string;
    readonly parentSpanId?: string;
    readonly traceState?: string;
};
type StructuredLogSinkOptions = {
    readonly minLevel?: LogLevel;
    readonly clock?: () => number;
    readonly write?: (record: StructuredLogRecord) => void;
    readonly redact?: RedactionConfig;
};
type StructuredLogSource = {
    readonly exportRecords: () => readonly StructuredLogRecord[];
} | (() => readonly StructuredLogRecord[]);
declare function makeStructuredLogSink(options?: StructuredLogSinkOptions): RuntimeHooks;
declare function formatStructuredLog(record: StructuredLogRecord): string;
declare function structuredLogsToOtlp(records: readonly StructuredLogRecord[], options?: OtlpExportOptions): {
    resourceLogs: {
        resource: {
            attributes: {
                key: string;
                value: {
                    boolValue: boolean;
                    doubleValue?: undefined;
                    stringValue?: undefined;
                } | {
                    doubleValue: number;
                    boolValue?: undefined;
                    stringValue?: undefined;
                } | {
                    stringValue: string;
                    boolValue?: undefined;
                    doubleValue?: undefined;
                };
            }[];
        };
        scopeLogs: {
            scope: Record<string, unknown>;
            logRecords: {
                attributes: {
                    key: string;
                    value: {
                        boolValue: boolean;
                        doubleValue?: undefined;
                        stringValue?: undefined;
                    } | {
                        doubleValue: number;
                        boolValue?: undefined;
                        stringValue?: undefined;
                    } | {
                        stringValue: string;
                        boolValue?: undefined;
                        doubleValue?: undefined;
                    };
                }[];
                spanId?: string | undefined;
                traceId?: string | undefined;
                timeUnixNano: string;
                severityText: string;
                severityNumber: number;
                body: {
                    stringValue: string;
                };
            }[];
        }[];
    }[];
};
declare function makeOtlpHttpLogExporter(source: StructuredLogSource, options: OtlpHttpExporterOptions): {
    export: () => Promise<{
        status: number | undefined;
        body: string;
        logCount: number;
    }>;
};
declare function logEffect(level: LogLevel, message: string, fields?: Record<string, unknown>): Async<unknown, never, void>;
declare function withLogContext<R, E, A>(patch: Record<string, JSONValue>, effect: Async<R, E, A>): Async<R, E, A>;
declare function defaultStructuredLogWriter(record: StructuredLogRecord): void;

type TraceContextHeaderValue = string | readonly string[] | undefined;
type TraceContextCarrier = Record<string, TraceContextHeaderValue> | Iterable<readonly [string, string]> | {
    get(name: string): string | null | undefined;
};
type InjectTraceContextOptions = {
    readonly overwrite?: boolean;
};
declare function parseTraceparent(value: string | null | undefined): TraceContext | undefined;
declare function formatTraceparent(trace: TraceContext): string;
declare function extractTraceContext(headers: TraceContextCarrier | undefined): TraceContext | undefined;
declare function injectTraceContext(headers: Record<string, string> | undefined, trace: TraceContext, options?: InjectTraceContextOptions): Record<string, string>;
declare function parseBaggage(value: string | null | undefined): Baggage | undefined;
declare function formatBaggage(baggage: Baggage | undefined): string;
declare function extractBaggage(headers: TraceContextCarrier | undefined): Baggage | undefined;
declare function injectBaggage(headers: Record<string, string> | undefined, baggage: Baggage | undefined, options?: InjectTraceContextOptions): Record<string, string>;
declare function normalizeTraceId(id: string): string;
declare function normalizeSpanId(id: string): string;

type ExportSignal = "metrics" | "traces" | "logs";
type ExportRetryOptions = {
    readonly attempts?: number;
    readonly initialDelayMs?: number;
    readonly maxDelayMs?: number;
    readonly jitterRatio?: number;
    readonly sleep?: (ms: number) => Promise<void>;
};
type ExportPipelineTuning = {
    readonly maxQueueSize?: number;
    readonly batchSize?: number;
    readonly timeoutMs?: number;
    readonly retry?: ExportRetryOptions;
    readonly dropPolicy?: "drop-oldest" | "drop-newest";
    readonly shutdownTimeoutMs?: number;
};
type ExportBatchResult = {
    readonly status?: number;
    readonly body?: string;
};
type ExportPipelineOptions<T> = ExportPipelineTuning & {
    readonly signal: ExportSignal;
    readonly metrics?: MetricsRegistry;
    readonly clock?: () => number;
    readonly exportBatch: (items: readonly T[]) => Promise<ExportBatchResult>;
    readonly onDrop?: (items: readonly T[]) => void;
};
type ExportPipelineFlushOptions = {
    readonly deadlineMs?: number;
};
type ExportPipelineFlushResult = {
    readonly exported: number;
    readonly dropped: number;
    readonly failed: number;
    readonly batchCount: number;
    readonly attempts: number;
    readonly queueSize: number;
    readonly status?: number;
    readonly body?: string;
    readonly errors: readonly unknown[];
};
type ExportPipelineStats = {
    readonly queueSize: number;
    readonly dropped: number;
};
type ExportPipeline<T> = {
    readonly enqueue: (items: readonly T[]) => number;
    readonly flush: (options?: ExportPipelineFlushOptions) => Promise<ExportPipelineFlushResult>;
    readonly shutdown: (timeoutMs?: number) => Promise<ExportPipelineFlushResult>;
    readonly stats: () => ExportPipelineStats;
};
declare function makeExportPipeline<T>(options: ExportPipelineOptions<T>): ExportPipeline<T>;
declare function exportWithRetry<T>(operation: () => Promise<T>, options: {
    readonly signal: ExportSignal;
    readonly metrics?: MetricsRegistry;
    readonly retry?: ExportRetryOptions;
}): Promise<{
    value: T;
    attempts: number;
}>;
declare function withTimeout<T>(operation: () => Promise<T>, timeoutMs: number): Promise<T>;

type CardinalityLimiterOptions = {
    readonly maxValuesPerLabel?: number;
    readonly overflowValue?: string;
};
type CardinalityConfig = false | CardinalityLimiterOptions;
declare function makeCardinalityLimitedMetrics(registry: MetricsRegistry, options?: CardinalityLimiterOptions): MetricsRegistry;
declare function normalizeHttpRoute(path: string | undefined): string | undefined;
declare function sanitizeHttpTarget(url: string | undefined): string | undefined;

type TraceSamplingRule = {
    readonly name?: string | RegExp;
    readonly route?: string | RegExp;
    readonly ratio?: number;
    readonly sampled?: boolean;
};
type TraceSamplingOptions = {
    readonly ratio?: number;
    readonly rules?: readonly TraceSamplingRule[];
    readonly sampler?: TraceSampler;
    readonly respectRemoteSampled?: boolean;
    readonly forceSampleOnError?: boolean;
};
type ResolvedTraceSampling = {
    readonly sampler: TraceSampler;
    readonly respectRemoteSampled: boolean;
    readonly forceSampleOnError: boolean;
};
type TraceSamplingConfig = false | number | TraceSampler | TraceSamplingOptions;
declare const alwaysOnSampler: TraceSampler;
declare const alwaysOffSampler: TraceSampler;
declare function ratioSampler(ratio: number): TraceSampler;
declare function makeTraceSampler(options?: TraceSamplingOptions): TraceSampler;
declare function resolveTraceSampling(config: TraceSamplingConfig | undefined): ResolvedTraceSampling;
declare function shouldSampleWith(sampler: TraceSampler | undefined, input: TraceSamplingInput): boolean;

type HealthStatus = "ok" | "degraded" | "down";
type HealthCheckResult = {
    readonly status: HealthStatus;
    readonly message?: string;
    readonly details?: Record<string, unknown>;
};
type HealthCheck = () => HealthCheckResult;
type RuntimeHealthOptions = {
    readonly runtime?: Runtime<any>;
    readonly registry?: RuntimeRegistry;
    readonly metrics?: MetricsRegistry;
    readonly circuitBreakers?: Record<string, {
        stats: () => CircuitBreakerStats;
    }>;
    readonly adaptiveLimiters?: Record<string, {
        stats: () => AdaptiveLimiterStats;
    }>;
    readonly checks?: Record<string, HealthCheck>;
    readonly clock?: () => number;
    readonly readiness?: {
        readonly failOnDegraded?: boolean;
    };
};
type RuntimeHealthReport = {
    readonly status: HealthStatus;
    readonly ready: boolean;
    readonly checkedAt: string;
    readonly fibers?: {
        readonly active: number;
        readonly suspended: number;
        readonly done: number;
    };
    readonly scopes?: {
        readonly open: number;
        readonly closed: number;
    };
    readonly runtime?: {
        readonly engine?: string;
        readonly fiberStats?: unknown;
        readonly scheduler?: unknown;
    };
    readonly metrics?: {
        readonly counters: number;
        readonly gauges: number;
        readonly histograms: number;
        readonly activeFibers?: number;
        readonly activeScopes?: number;
        readonly activeSpans?: number;
    };
    readonly circuitBreakers: Record<string, CircuitBreakerStats & {
        readonly status: HealthStatus;
    }>;
    readonly adaptiveLimiters: Record<string, AdaptiveLimiterStats & {
        readonly status: HealthStatus;
    }>;
    readonly checks: Record<string, HealthCheckResult>;
};
type HealthHttpResponse = {
    readonly status: number;
    readonly headers: Record<string, string>;
    readonly body: string;
};
declare function snapshotRuntimeHealth(options?: RuntimeHealthOptions): RuntimeHealthReport;
declare function makeRuntimeHealth(options?: RuntimeHealthOptions): Async<unknown, never, RuntimeHealthReport>;
declare const runtimeHealth: typeof makeRuntimeHealth;
declare function readiness(options?: RuntimeHealthOptions): Async<unknown, never, boolean>;
declare function healthToHttpResponse(report: RuntimeHealthReport): HealthHttpResponse;

type ObservabilityOtlpOptions = {
    readonly metricsUrl?: string;
    readonly tracesUrl?: string;
    readonly logsUrl?: string;
    readonly headers?: Record<string, string>;
    readonly fetch?: OtlpFetch;
    readonly timeoutMs?: number;
    readonly retry?: ExportRetryOptions;
    readonly pipeline?: ExportPipelineTuning;
};
type ObservabilityOtlpSignal = "metrics" | "traces" | "logs";
type MakeOtlpOptionsInput = {
    readonly endpoint: string;
    readonly headers?: ObservabilityOtlpOptions["headers"];
    readonly fetch?: ObservabilityOtlpOptions["fetch"];
    readonly timeoutMs?: ObservabilityOtlpOptions["timeoutMs"];
    readonly retry?: ObservabilityOtlpOptions["retry"];
    readonly pipeline?: ObservabilityOtlpOptions["pipeline"];
    readonly signals?: readonly ObservabilityOtlpSignal[];
};
declare function makeOtlpOptions(input: MakeOtlpOptionsInput): ObservabilityOtlpOptions;
type ObservabilityOptions = {
    readonly serviceName?: string;
    readonly serviceVersion?: string;
    readonly resource?: Record<string, OtlpAttributeValue>;
    readonly eventBus?: EventBus;
    readonly metrics?: false | (RuntimeMetricsSinkOptions & {
        readonly prometheus?: PrometheusMetricsOptions;
    });
    readonly logs?: false | StructuredLogSinkOptions;
    readonly traces?: false | Omit<InMemoryTracerOptions, "sanitizeAttributes" | "sanitizeError">;
    readonly sampling?: TraceSamplingConfig;
    readonly redaction?: RedactionConfig;
    readonly cardinality?: CardinalityConfig;
    readonly otlp?: ObservabilityOtlpOptions;
    readonly flushIntervalMs?: number;
    readonly autoStart?: boolean;
    readonly traceSeed?: TraceContext;
    readonly childName?: (parentName?: string) => string | undefined;
    readonly onFlushError?: (error: unknown, signal: "metrics" | "traces" | "logs") => void;
};
type ObservabilityRequestEnvInput = TraceContextCarrier | {
    readonly headers?: TraceContextCarrier;
    readonly trace?: TraceContext;
    readonly traceparent?: string;
    readonly tracestate?: string;
    readonly baggage?: Baggage | string;
};
type ObservabilityFlushError = {
    readonly signal: "metrics" | "traces" | "logs";
    readonly error: unknown;
};
type ObservabilityTraceExportResult = OtlpHttpExportResult & {
    readonly spanCount: number;
};
type ObservabilityLogExportResult = OtlpHttpExportResult & {
    readonly logCount: number;
};
type ObservabilityFlushResult = {
    readonly metrics?: OtlpHttpExportResult;
    readonly traces?: ObservabilityTraceExportResult;
    readonly logs?: ObservabilityLogExportResult;
    readonly errors: readonly ObservabilityFlushError[];
};
type ObservabilityExporters = {
    readonly prometheus: PrometheusMetricsExporter;
    readonly otlpMetrics?: {
        readonly export: () => Promise<OtlpHttpExportResult>;
    };
    readonly otlpTraces?: {
        readonly export: () => Promise<ObservabilityTraceExportResult>;
        readonly pipeline: ExportPipeline<RuntimeSpan>;
    };
    readonly otlpLogs?: {
        readonly export: () => Promise<ObservabilityLogExportResult>;
        readonly pipeline: ExportPipeline<StructuredLogRecord>;
    };
};
type ObservabilityRuntimeEnv = BrassEnv;
type Observability = {
    readonly hooks: EventBus;
    readonly eventBus: EventBus;
    readonly env: ObservabilityRuntimeEnv;
    readonly envForRequest: (input?: ObservabilityRequestEnvInput) => ObservabilityRuntimeEnv;
    readonly metrics: MetricsRegistry;
    readonly tracer: InMemoryTracer;
    readonly traceIdGenerator: Tracer;
    readonly exporters: ObservabilityExporters;
    readonly prometheus: PrometheusMetricsExporter;
    readonly health: (options?: Omit<RuntimeHealthOptions, "metrics">) => RuntimeHealthReport;
    readonly readiness: (options?: Omit<RuntimeHealthOptions, "metrics">) => boolean;
    readonly flush: () => Promise<ObservabilityFlushResult>;
    readonly start: () => void;
    readonly stop: () => void;
    readonly shutdown: () => Promise<ObservabilityFlushResult>;
};
declare function makeObservability(options?: ObservabilityOptions): Observability;
declare function resolveRequestTraceSeed(input?: ObservabilityRequestEnvInput): TraceContext | undefined;
declare function resolveRequestBaggage(input?: ObservabilityRequestEnvInput): Baggage | undefined;

type SpanAttributes = Record<string, string | number | boolean>;
type SpanLink = {
    readonly traceId: string;
    readonly spanId: string;
    readonly traceState?: string;
    readonly attributes?: SpanAttributes;
};
type SpanOptions = {
    readonly attributes?: SpanAttributes;
    readonly links?: readonly SpanLink[];
};
type SpanSource = {
    readonly exportFinished: () => readonly RuntimeSpan[];
} | (() => readonly RuntimeSpan[]);
declare function withSpan<R, E, A>(name: string, effect: Async<R, E, A>, attributesOrOptions?: SpanAttributes | SpanOptions): Async<R, E, A>;
declare function spanLink(trace: TraceContext, attributes?: SpanAttributes): SpanLink;
declare function currentSpanLink(attributes?: SpanAttributes): SpanLink | undefined;
declare function withBaggage<R, E, A>(baggage: Baggage, effect: Async<R, E, A>): Async<R, E, A>;
declare function currentBaggage(): Baggage | undefined;
declare function spanEvent(name: string, attributes?: SpanAttributes): Async<unknown, never, void>;
declare function spansToOtlp(spans: readonly RuntimeSpan[], options?: OtlpExportOptions): {
    resourceSpans: {
        resource: {
            attributes: {
                key: string;
                value: {
                    boolValue: boolean;
                    doubleValue?: undefined;
                    stringValue?: undefined;
                } | {
                    doubleValue: number;
                    boolValue?: undefined;
                    stringValue?: undefined;
                } | {
                    stringValue: string;
                    boolValue?: undefined;
                    doubleValue?: undefined;
                };
            }[];
        };
        scopeSpans: {
            scope: Record<string, unknown>;
            spans: {
                name: string;
                kind: number;
                startTimeUnixNano: string;
                endTimeUnixNano: string;
                attributes: {
                    key: string;
                    value: {
                        boolValue: boolean;
                        doubleValue?: undefined;
                        stringValue?: undefined;
                    } | {
                        doubleValue: number;
                        boolValue?: undefined;
                        stringValue?: undefined;
                    } | {
                        stringValue: string;
                        boolValue?: undefined;
                        doubleValue?: undefined;
                    };
                }[];
                events: {
                    name: string;
                    timeUnixNano: string;
                    attributes: {
                        key: string;
                        value: {
                            boolValue: boolean;
                            doubleValue?: undefined;
                            stringValue?: undefined;
                        } | {
                            doubleValue: number;
                            boolValue?: undefined;
                            stringValue?: undefined;
                        } | {
                            stringValue: string;
                            boolValue?: undefined;
                            doubleValue?: undefined;
                        };
                    }[];
                }[];
                links: {
                    attributes: {
                        key: string;
                        value: {
                            boolValue: boolean;
                            doubleValue?: undefined;
                            stringValue?: undefined;
                        } | {
                            doubleValue: number;
                            boolValue?: undefined;
                            stringValue?: undefined;
                        } | {
                            stringValue: string;
                            boolValue?: undefined;
                            doubleValue?: undefined;
                        };
                    }[];
                    traceState?: string | undefined;
                    traceId: string;
                    spanId: string;
                }[];
                status: {
                    code: number;
                    message: any;
                } | {
                    code: number;
                    message?: undefined;
                };
                traceState?: string | undefined;
                parentSpanId?: string | undefined;
                traceId: string;
                spanId: string;
            }[];
        }[];
    }[];
};
declare function makeOtlpHttpSpanExporter(source: SpanSource, options: OtlpHttpExporterOptions): {
    export: () => Promise<{
        status: number | undefined;
        body: string;
    }>;
};

type RequestObservabilityContextInput = {
    readonly headers?: TraceContextCarrier;
    readonly trace?: TraceContext;
    readonly traceparent?: string;
    readonly tracestate?: string;
    readonly baggage?: Baggage | string;
    readonly method?: string;
    readonly target?: string;
    readonly route?: string;
    readonly spanName?: string;
    readonly attributes?: SpanAttributes;
};
type RequestObservabilityRuntimeOptions<R extends object> = Omit<RuntimeOptions<R & ObservabilityRuntimeEnv>, "env" | "hooks">;
type RequestObservabilityContext = {
    readonly env: ObservabilityRuntimeEnv;
    readonly trace?: TraceContext;
    readonly route?: string;
    readonly attributes: SpanAttributes;
    readonly makeRuntime: <R extends object = {}>(env?: R, options?: RequestObservabilityRuntimeOptions<R>) => Runtime<R & ObservabilityRuntimeEnv>;
    readonly run: <R extends object = {}, E = never, A = never>(effect: Async<R & ObservabilityRuntimeEnv, E, A>, env?: R, options?: RequestObservabilityRuntimeOptions<R>) => Promise<A>;
    readonly span: <R, E, A>(name: string, effect: Async<R, E, A>, attributes?: SpanAttributes) => Async<R, E, A>;
    readonly withRequestSpan: <R, E, A>(effect: Async<R, E, A>, attributes?: SpanAttributes) => Async<R, E, A>;
    readonly flush: () => Promise<ObservabilityFlushResult>;
    readonly shutdown: () => Promise<ObservabilityFlushResult>;
};
declare function makeRequestObservabilityContext(observability: Observability, input?: RequestObservabilityContextInput): RequestObservabilityContext;

type HttpServerOutcome = "success" | "error" | "exception";
type HttpServerObservabilityLogOptions = {
    readonly requestLevel?: LogLevel | false;
    readonly responseLevel?: LogLevel | false;
    readonly errorLevel?: LogLevel | false;
};
type HttpServerObservabilitySpanOptions = {
    readonly name?: string | ((input: RequestObservabilityContextInput) => string);
    readonly attributes?: SpanAttributes | ((input: RequestObservabilityContextInput) => SpanAttributes);
};
type HttpServerObservabilityOptions<A = unknown> = {
    readonly metrics?: MetricsRegistry | false;
    readonly logs?: false | HttpServerObservabilityLogOptions;
    readonly spans?: false | HttpServerObservabilitySpanOptions;
    readonly includeRouteLabel?: boolean;
    readonly clock?: () => number;
    readonly durationBuckets?: readonly number[];
    readonly statusCode?: (value: A) => number | undefined;
};
type ObservedHttpServerResult<A> = {
    readonly value: A;
    readonly ctx: RequestObservabilityContext;
    readonly statusCode: number;
    readonly durationMs: number;
};
declare function runObservedHttpServerEffect<R extends object = {}, E = never, A = never>(observability: Observability, input: RequestObservabilityContextInput, effect: Async<R, E, A>, options?: HttpServerObservabilityOptions<A>, env?: R, runtimeOptions?: RequestObservabilityRuntimeOptions<R>): Promise<ObservedHttpServerResult<A>>;
declare function observeHttpServerRequest<A>(observability: Observability, input: RequestObservabilityContextInput, handler: (ctx: RequestObservabilityContext) => Promise<A>, options?: HttpServerObservabilityOptions<A>): Promise<ObservedHttpServerResult<A>>;

export { type RuntimeHealthOptions as $, type ObservabilityRedactor as A, type ObservabilityRequestEnvInput as B, type CardinalityConfig as C, type ObservabilityTraceExportResult as D, type ExportBatchResult as E, type ObservedHttpServerResult as F, type OtlpAttributeValue as G, type HealthCheck as H, type InjectTraceContextOptions as I, type OtlpExportOptions as J, type OtlpFetch as K, type LogLevel as L, type MakeOtlpOptionsInput as M, type OtlpHttpExportResult as N, type Observability as O, type OtlpHttpExporterOptions as P, type OtlpHttpResponse as Q, type RequestObservabilityContextInput as R, type SpanAttributes as S, type TraceContextCarrier as T, PROMETHEUS_CONTENT_TYPE as U, type PrometheusMetricsExporter as V, type PrometheusMetricsOptions as W, type RedactionConfig as X, type RedactionOptions as Y, type RequestObservabilityRuntimeOptions as Z, type ResolvedTraceSampling as _, type RequestObservabilityContext as a, spanLink as a$, type RuntimeHealthReport as a0, type RuntimeMetricsSinkOptions as a1, type SpanLink as a2, type SpanOptions as a3, type SpanSource as a4, type StructuredLogRecord as a5, type StructuredLogSinkOptions as a6, type StructuredLogSource as a7, type TraceContextHeaderValue as a8, type TraceSamplingConfig as a9, makeOtlpOptions as aA, makePrometheusMetricsExporter as aB, makeRequestObservabilityContext as aC, makeRuntimeHealth as aD, makeRuntimeMetricsSink as aE, makeStructuredLogSink as aF, makeTraceSampler as aG, metricsSnapshotToOtlp as aH, normalizeHttpRoute as aI, normalizeSpanId as aJ, normalizeTraceId as aK, observeHttpServerRequest as aL, otlpAnyValue as aM, parseBaggage as aN, parseTraceparent as aO, postOtlpJson as aP, ratioSampler as aQ, readiness as aR, resolveRequestBaggage as aS, resolveRequestTraceSeed as aT, resolveTraceSampling as aU, runObservedHttpServerEffect as aV, runtimeHealth as aW, sanitizeHttpTarget as aX, shouldSampleWith as aY, snapshotRuntimeHealth as aZ, spanEvent as a_, type TraceSamplingOptions as aa, type TraceSamplingRule as ab, alwaysOffSampler as ac, alwaysOnSampler as ad, currentBaggage as ae, currentSpanLink as af, defaultStructuredLogWriter as ag, exemplarFromTraceContext as ah, exportWithRetry as ai, extractBaggage as aj, extractTraceContext as ak, formatBaggage as al, formatPrometheusMetrics as am, formatStructuredLog as an, formatTraceparent as ao, healthToHttpResponse as ap, injectBaggage as aq, injectTraceContext as ar, logEffect as as, makeCardinalityLimitedMetrics as at, makeExportPipeline as au, makeObservability as av, makeObservabilityRedactor as aw, makeOtlpHttpLogExporter as ax, makeOtlpHttpMetricsExporter as ay, makeOtlpHttpSpanExporter as az, type ObservabilityOptions as b, spansToOtlp as b0, structuredLogsToOtlp as b1, toOtlpAttributes as b2, unixNanoFromMs as b3, withBaggage as b4, withLogContext as b5, withSpan as b6, withTimeout as b7, type ObservabilityRuntimeEnv as c, type CardinalityLimiterOptions as d, type ExportPipeline as e, type ExportPipelineFlushOptions as f, type ExportPipelineFlushResult as g, type ExportPipelineOptions as h, type ExportPipelineStats as i, type ExportPipelineTuning as j, type ExportRetryOptions as k, type ExportSignal as l, type HealthCheckResult as m, type HealthHttpResponse as n, type HealthStatus as o, type HttpServerObservabilityLogOptions as p, type HttpServerObservabilityOptions as q, type HttpServerObservabilitySpanOptions as r, type HttpServerOutcome as s, OTLP_JSON_CONTENT_TYPE as t, type ObservabilityExporters as u, type ObservabilityFlushError as v, type ObservabilityFlushResult as w, type ObservabilityLogExportResult as x, type ObservabilityOtlpOptions as y, type ObservabilityOtlpSignal as z };