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

type HttpOutcome = "success" | "error" | "abort" | "bad_url" | "fetch_error" | "timeout" | "pool_rejected" | "pool_timeout" | "pool_closed" | "batch_split_error";
type HttpObservabilityLogOptions = {
    readonly requestLevel?: LogLevel | false;
    readonly responseLevel?: LogLevel | false;
    readonly errorLevel?: LogLevel | false;
};
type HttpObservabilitySpanOptions = {
    readonly name?: string | ((req: HttpRequest) => string);
    readonly attributes?: SpanAttributes | ((req: HttpRequest) => SpanAttributes);
    readonly events?: boolean;
    readonly sampleRate?: number;
};
type HttpAdaptiveLimiterObservabilityOptions = {
    readonly enabled?: boolean;
    /**
     * Adds a `key` metric label when a stable limiter key can be inferred.
     * Keep disabled for high-cardinality downstreams.
     */
    readonly includeKeyLabel?: boolean;
};
type HttpPolicyLabelKey = "preset" | "lane" | "poolKey" | "dedupKey" | "priority" | "retry";
type HttpPolicyObservabilityOptions = {
    readonly enabled?: boolean;
    /**
     * Adds selected policy fields as metric labels. Disabled by default because
     * pool keys, lanes, and dedup keys may be high-cardinality in user systems.
     */
    readonly labelKeys?: readonly HttpPolicyLabelKey[];
};
type HttpObservabilityOptions = {
    readonly metrics?: MetricsRegistry | false;
    readonly logs?: false | HttpObservabilityLogOptions;
    readonly spans?: false | HttpObservabilitySpanOptions;
    readonly spanSink?: RuntimeHooks | false;
    readonly adaptiveLimiter?: boolean | HttpAdaptiveLimiterObservabilityOptions;
    readonly policy?: boolean | HttpPolicyObservabilityOptions;
    readonly injectTraceHeaders?: boolean;
    readonly includeHostLabel?: boolean;
    readonly route?: string | ((req: HttpRequest) => string | undefined);
    readonly clock?: () => number;
    readonly durationBuckets?: readonly number[];
};
declare const HTTP_OBSERVABILITY_CONTRACT: Readonly<{
    readonly metrics: Readonly<{
        requestsTotal: "brass_http_client_requests_total";
        durationMs: "brass_http_client_duration_ms";
        inFlight: "brass_http_client_in_flight";
        adaptiveLimiterLimit: "brass_http_adaptive_limiter_limit";
        adaptiveLimiterInFlight: "brass_http_adaptive_limiter_in_flight";
        adaptiveLimiterQueueDepth: "brass_http_adaptive_limiter_queue_depth";
        adaptiveLimiterStateCount: "brass_http_adaptive_limiter_state_count";
        adaptiveLimiterUtilization: "brass_http_adaptive_limiter_utilization";
        adaptiveLimiterErrorRate: "brass_http_adaptive_limiter_error_rate";
        adaptiveLimiterRequestsPerSecond: "brass_http_adaptive_limiter_requests_per_second";
        adaptiveLimiterCompletionsPerSecond: "brass_http_adaptive_limiter_completions_per_second";
        adaptiveLimiterRejectionRate: "brass_http_adaptive_limiter_rejection_rate";
    }>;
    readonly labels: Readonly<{
        method: "method";
        host: "host";
        route: "route";
        outcome: "outcome";
        status: "status";
        adaptiveLimiterKey: "key";
        lane: "lane";
        poolKey: "pool_key";
        dedupKey: "dedup_key";
        priority: "priority";
        retry: "retry";
        policy: "policy";
    }>;
    readonly spanAttributes: Readonly<{
        method: "http.request.method";
        url: "url.full";
        route: "http.route";
        host: "server.address";
        durationMs: "http.duration_ms";
        outcome: "http.outcome";
        statusCode: "http.status_code";
        retryable: "http.retryable";
        policyLane: "http.request.policy.lane";
        policyPreset: "http.request.policy.preset";
        policyPoolKey: "http.request.policy.pool_key";
        policyDedupKey: "http.request.policy.dedup_key";
        policyPriority: "http.request.policy.priority";
        policyRetry: "http.request.policy.retry";
    }>;
    readonly logMessages: Readonly<{
        request: "http.client.request";
        response: "http.client.response";
        error: "http.client.error";
    }>;
    readonly logFields: Readonly<{
        method: "method";
        url: "url";
        host: "host";
        route: "route";
        status: "status";
        outcome: "outcome";
        durationMs: "durationMs";
        retryable: "retryable";
        policy: "policy";
    }>;
}>;
declare function withHttpObservability(options?: Observability | HttpObservabilityOptions): HttpMiddleware;
declare const makeHttpObservabilityMiddleware: typeof withHttpObservability;

type FetchLikeRequest = {
    readonly headers?: TraceContextCarrier;
    readonly method?: string;
    readonly url?: string;
};
type NodeLikeIncomingMessage = {
    readonly headers?: Record<string, string | readonly string[] | undefined>;
    readonly method?: string;
    readonly url?: string;
};
type ExpressLikeRequest = NodeLikeIncomingMessage & {
    readonly originalUrl?: string;
    readonly path?: string;
    readonly route?: {
        readonly path?: string;
    };
};
type FastifyLikeRequest = NodeLikeIncomingMessage & {
    readonly routeOptions?: {
        readonly url?: string;
    };
    readonly routerPath?: string;
};
declare function makeFetchRequestObservabilityContext(observability: Observability, request: FetchLikeRequest, input?: RequestObservabilityContextInput): RequestObservabilityContext;
declare function makeNodeRequestObservabilityContext(observability: Observability, request: NodeLikeIncomingMessage, input?: RequestObservabilityContextInput): RequestObservabilityContext;
declare function makeExpressRequestObservabilityContext(observability: Observability, request: ExpressLikeRequest, input?: RequestObservabilityContextInput): RequestObservabilityContext;
declare function makeFastifyRequestObservabilityContext(observability: Observability, request: FastifyLikeRequest, input?: RequestObservabilityContextInput): RequestObservabilityContext;
declare function withFetchRequestObservability<RequestLike extends FetchLikeRequest, A>(observability: Observability, handler: (ctx: RequestObservabilityContext, request: RequestLike) => A | Promise<A>, input?: RequestObservabilityContextInput): (request: RequestLike) => Promise<A>;
declare function withNodeRequestObservability<RequestLike extends NodeLikeIncomingMessage, A>(observability: Observability, handler: (ctx: RequestObservabilityContext, request: RequestLike) => A | Promise<A>, input?: RequestObservabilityContextInput): (request: RequestLike) => Promise<A>;

type ObservabilityPreset = "development" | "production" | "test" | "disabled";
type ObservabilityEnv = Record<string, string | undefined>;
declare function makeNoopObservability(): Observability;
declare function makeObservabilityPreset(preset: ObservabilityPreset, overrides?: ObservabilityOptions): Observability;
declare function makeObservabilityFromEnv(env?: ObservabilityEnv, overrides?: ObservabilityOptions): Observability;
declare function observabilityOptionsForPreset(preset: Exclude<ObservabilityPreset, "disabled">): ObservabilityOptions;
declare function observabilityOptionsFromEnv(env?: ObservabilityEnv, preset?: Exclude<ObservabilityPreset, "disabled">): ObservabilityOptions;

declare const ObservabilityService: ServiceTag<Observability>;
type ObservabilityLayerConfig = ObservabilityOptions | ((context: LayerContext) => ObservabilityOptions);
type ObservabilityLayerOptions = {
    readonly tag?: ServiceTag<Observability>;
};
type ObservedHttpClientLayerConfig = DefaultHttpClientConfig | ((context: LayerContext, observability: Observability) => DefaultHttpClientConfig);
type ObservedHttpClientLayerOptions = {
    readonly observabilityTag?: ServiceTag<Observability>;
    readonly httpTag?: ServiceTag<DefaultHttpClient>;
    readonly httpObservability?: HttpObservabilityOptions | ((context: LayerContext, observability: Observability) => HttpObservabilityOptions);
};
type ObservedRuntimeLayerEnv<R extends object> = R | ((context: LayerContext, observability: Observability) => R);
type ObservedRuntimeLayerOptions<R extends object> = Omit<RuntimeOptions<R & ObservabilityRuntimeEnv>, "env" | "hooks"> & {
    readonly observabilityTag?: ServiceTag<Observability>;
    readonly runtimeTag?: ServiceTag<Runtime<R & ObservabilityRuntimeEnv>>;
    readonly env?: ObservedRuntimeLayerEnv<R>;
};
declare function makeObservabilityLayer(config?: ObservabilityLayerConfig, options?: ObservabilityLayerOptions): Layer<LayerContext, unknown, LayerContext>;
declare function makeObservedRuntimeLayer<R extends object = {}>(options?: ObservedRuntimeLayerOptions<R>): Layer<LayerContext, unknown, LayerContext>;
declare function makeObservedHttpClientLayer(config?: ObservedHttpClientLayerConfig, options?: ObservedHttpClientLayerOptions): Layer<LayerContext, unknown, LayerContext>;

export { type ExpressLikeRequest, type FastifyLikeRequest, type FetchLikeRequest, HTTP_OBSERVABILITY_CONTRACT, type HttpAdaptiveLimiterObservabilityOptions, type HttpObservabilityLogOptions, type HttpObservabilityOptions, type HttpObservabilitySpanOptions, type HttpOutcome, type HttpPolicyLabelKey, type HttpPolicyObservabilityOptions, LogLevel, type NodeLikeIncomingMessage, Observability, type ObservabilityEnv, type ObservabilityLayerConfig, type ObservabilityLayerOptions, ObservabilityOptions, type ObservabilityPreset, ObservabilityRuntimeEnv, ObservabilityService, type ObservedHttpClientLayerConfig, type ObservedHttpClientLayerOptions, type ObservedRuntimeLayerEnv, type ObservedRuntimeLayerOptions, RequestObservabilityContext, RequestObservabilityContextInput, SpanAttributes, TraceContextCarrier, makeExpressRequestObservabilityContext, makeFastifyRequestObservabilityContext, makeFetchRequestObservabilityContext, makeHttpObservabilityMiddleware, makeNodeRequestObservabilityContext, makeNoopObservability, makeObservabilityFromEnv, makeObservabilityLayer, makeObservabilityPreset, makeObservedHttpClientLayer, makeObservedRuntimeLayer, observabilityOptionsForPreset, observabilityOptionsFromEnv, withFetchRequestObservability, withHttpObservability, withNodeRequestObservability };